| Server IP : 209.209.40.120 / Your IP : 216.73.217.112 Web Server : Microsoft-IIS/10.0 System : Windows NT NEWWWW 10.0 build 17763 (Windows Server 2019) i586 User : NEWWWW$ ( 0) PHP Version : 8.3.30 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/Users/All Users/MySQL/MySQL Server 5.7/Data/mysql/ |
Upload File : |
���r #�� @ � ! * ���� ���� � � ���� ���� ���� ���� & & ���� ���� ���������������� ���� ���� �������������� ���r #���9M� $� 0 3 �9M� $��_9� #�� ���� ���� ���� ���� ���� ���� ���� ���� �i� ���������������������������������������������������������������������������������������������������������������������������� ���� ���� � � ���� ���� �i�
! " # $ % & ' ���� ���� ���� ���� ���� ���� �i� ���������������������������������������������������������������������������������������������������������������������������� ���� ���� ���� ���� ���� ���� �i� ( )������������������������������������������������������������������������������������������������������������ �_9� #���^ j �������� #��E� �6 3 4 � 2 infimum supremum
!
)
/ 1
G 9
^
A
w I
� Q
�
Y
� a
� i
� q
� y
� �
�
�
4 �
S �
l �
{ �
� �
� �
� �
� �
� ! �
� " �
� # �
� $ �
� % �
� &
� '
� B
F
G !
H)
I 1
J 9
K A
! LI
) O Q
- Q Y
5 R a
B Si
I U q
P V y
X W �
a X�
k Y �
w [ �
\ �
� ] ��\ � ^ p��xD��t@ � � c�^ j #�ȑ�q� �������� #�E� �� � r � infimum supremum@ �! L @ NINSERT FUNCTION � @ ! �SESSION_USER @ )�dCREATE SERVER � (@ 1��SIGNAL E ) p c��q� #�B�l� ���� >�E� ;� � T infimum supremum W@ � "� 6HELP_DATE This help information was generated from the MySQL 5.7 Reference Manual
on: 2023-10-10
��@ � "� 6HELP_VERSION This help information was generated from the MySQL 5.7 Reference Manual
on: 2023-10-10 (revision: 76921)
This information applies to MySQL 5.7 through 5.7.44.
C����@ 7 "� 6 AUTO_INCREMENT The AUTO_INCREMENT attribute can be used to generate a unique identity
for new rows:
URL: https://dev.mysql.com/doc/refman/5.7/en/example-auto-increment.html
CREATE TABLE animals (
id MEDIUMINT NOT NULL AUTO_INCREMENT,
name CHAR(30) NOT NULL,
PRIMARY KEY (id)
);
INSERT INTO animals (name) VALUES
('dog'),('cat'),('penguin'),
('lax'),('whale'),('ostrich');
SELECT * FROM animals;
https://dev.mysql.com/doc/refman/5.7/en/example-auto-increment.htmlC ɉ@ (
i "� 6(HELP COMMAND Syntax:
mysql> help search_string
If you provide an argument to the help command, mysql uses it as a
search string to access server-side help from the contents of the MySQL
Reference Manual. The proper operation of this command requires that
the help tables in the mysql database be initialized with help topic
information (see
https://dev.mysql.com/doc/refman/5.7/en/server-side-help-support.html).
If there is no match for the search string, the search fails:
mysql> help me
Nothing found
Please try to run 'help contents' for a list of all accessible topics
Use help contents to see a list of the help categories:
mysql> help contents
You asked for help about help category: "Contents"
For more information, type 'help <item>', where <item> is one of the
following categories:
Account Management
Administration
Data Definition
Data Manipulation
Data Types
Functions
Functions and Modifiers for Use with GROUP BY
Geographic Features
Language Structure
Plugins
Storage Engines
Stored Routines
Table Maintenance
Transactions
Triggers
If the search string matches multiple items, mysql shows a list of
matching topics:
mysql> help logs
Many help items for your request exist.
To make a more specific request, please type 'help <item>',
where <item> is one of the following topics:
SHOW
SHOW BINARY LOGS
SHOW ENGINE
SHOW LOGS
Use a topic as the search string to see the help entry for that topic:
mysql> help show binary logs
Name: 'SHOW BINARY LOGS'
Description:
Syntax:
SHOW BINARY LOGS
SHOW MASTER LOGS
Lists the binary log files on the server. This statement is used as
part of the procedure described in [purge-binary-logs], that shows how
to determine which logs can be purged.
mysql> SHOW BINARY LOGS;
+---------------+-----------+
| Log_name | File_size |
+---------------+-----------+
| binlog.000015 | 724935 |
| binlog.000016 | 733481 |
+---------------+-----------+
The search string can contain the wildcard characters % and _. These
have the same meaning as for pattern-matching operations performed with
the LIKE operator. For example, HELP rep% returns a list of topics that
begin with rep:
mysql> HELP rep%
Many help items for your request exist.
To make a more specific request, please type 'help <item>',
where <item> is one of the following
topics:
REPAIR TABLE
REPEAT FUNCTION
REPEAT LOOP
REPLACE
REPLACE FUNCTION
URL: https://dev.mysql.com/doc/refman/5.7/en/mysql-server-side-help.html
https://dev.mysql.com/doc/refman/5.7/en/mysql-server-side-help.htmlL @ 0w "� 64ASYMMETRIC_DECRYPT Syntax:
asymmetric_decrypt(algorithm, crypt_str, key_str)
Decrypts an encrypted string using the given algorithm and key string,
and returns the resulting plaintext as a binary string. If decryption
fails, the result is NULL.
key_str must be a valid key string in PEM format. For successful
decryption, it must be the public or private key string corresponding
to the private or public key string used with asymmetric_encrypt() to
produce the encrypted string. algorithm indicates the encryption
algorithm used to create the key.
Supported algorithm values: 'RSA'
For a usage example, see the description of asymmetric_encrypt().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL �@ 8� "� 6@ASYMMETRIC_DERIVE Syntax:
asymmetric_derive(pub_key_str, priv_key_str)
Derives a symmetric key using the private key of one party and the
public key of another, and returns the resulting key as a binary
string. If key derivation fails, the result is NULL.
pub_key_str and priv_key_str must be valid key strings in PEM format.
They must be created using the DH algorithm.
Suppose that you have two pairs of public and private keys:
SET @dhp = create_dh_parameters(1024);
SET @priv1 = create_asymmetric_priv_key('DH', @dhp);
SET @pub1 = create_asymmetric_pub_key('DH', @priv1);
SET @priv2 = create_asymmetric_priv_key('DH', @dhp);
SET @pub2 = create_asymmetric_pub_key('DH', @priv2);
Suppose further that you use the private key from one pair and the
public key from the other pair to create a symmetric key string. Then
this symmetric key identity relationship holds:
asymmetric_derive(@pub1, @priv2) = asymmetric_derive(@pub2, @priv1)
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL�1�@ @� "� 6LASYMMETRIC_ENCRYPT Syntax:
asymmetric_encrypt(algorithm, str, key_str)
Encrypts a string using the given algorithm and key string, and returns
the resulting ciphertext as a binary string. If encryption fails, the
result is NULL.
The str length cannot be greater than the key_str length − 11, in
bytes
key_str must be a valid key string in PEM format. algorithm indicates
the encryption algorithm used to create the key.
Supported algorithm values: 'RSA'
To encrypt a string, pass a private or public key string to
asymmetric_encrypt(). To recover the original unencrypted string, pass
the encrypted string to asymmetric_decrypt(), along with the public or
private key string correponding to the private or public key string
used for encryption.
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
-- Generate private/public key pair
SET @priv = create_asymmetric_priv_key('RSA', 1024);
SET @pub = create_asymmetric_pub_key('RSA', @priv);
-- Encrypt using private key, decrypt using public key
SET @ciphertext = asymmetric_encrypt('RSA', 'The quick brown fox', @priv);
SET @plaintext = asymmetric_decrypt('RSA', @ciphertext, @pub);
-- Encrypt using public key, decrypt using private key
SET @ciphertext = asymmetric_encrypt('RSA', 'The quick brown fox', @pub);
SET @plaintext = asymmetric_decrypt('RSA', @ciphertext, @priv);
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL 8�@ H� "� 6XASYMMETRIC_SIGN Syntax:
asymmetric_sign(algorithm, digest_str, priv_key_str, digest_type)
Signs a digest string using a private key string, and returns the
signature as a binary string. If signing fails, the result is NULL.
digest_str is the digest string. It can be generated by calling
create_digest(). digest_type indicates the digest algorithm used to
generate the digest string.
priv_key_str is the private key string to use for signing the digest
string. It must be a valid key string in PEM format. algorithm
indicates the encryption algorithm used to create the key.
Supported algorithm values: 'RSA', 'DSA'
Supported digest_type values: 'SHA224', 'SHA256', 'SHA384', 'SHA512'
For a usage example, see the description of asymmetric_verify().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL ���@ PQ "� 6dASYMMETRIC_VERIFY Syntax:
asymmetric_verify(algorithm, digest_str, sig_str, pub_key_str,
digest_type)
Verifies whether the signature string matches the digest string, and
returns 1 or 0 to indicate whether verification succeeded or failed.
digest_str is the digest string. It can be generated by calling
create_digest(). digest_type indicates the digest algorithm used to
generate the digest string.
sig_str is the signature string. It can be generated by calling
asymmetric_sign().
pub_key_str is the public key string of the signer. It corresponds to
the private key passed to asymmetric_sign() to generate the signature
string and must be a valid key string in PEM format. algorithm
indicates the encryption algorithm used to create the key.
Supported algorithm values: 'RSA', 'DSA'
Supported digest_type values: 'SHA224', 'SHA256', 'SHA384', 'SHA512'
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
-- Set the encryption algorithm and digest type
SET @algo = 'RSA';
SET @dig_type = 'SHA224';
-- Create private/public key pair
SET @priv = create_asymmetric_priv_key(@algo, 1024);
SET @pub = create_asymmetric_pub_key(@algo, @priv);
-- Generate digest from string
SET @dig = create_digest(@dig_type, 'The quick brown fox');
-- Generate signature for digest and verify signature against digest
SET @sig = asymmetric_sign(@algo, @dig, @priv, @dig_type);
SET @verf = asymmetric_verify(@algo, @dig, @sig, @pub, @dig_type);
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlLi��@ X� "� 6pCREATE_ASYMMETRIC_PRIV_KEY Syntax:
create_asymmetric_priv_key(algorithm, {key_len|dh_secret})
Creates a private key using the given algorithm and key length or DH
secret, and returns the key as a binary string in PEM format. If key
generation fails, the result is NULL.
Supported algorithm values: 'RSA', 'DSA', 'DH'
Supported key_len values: The minimum key length in bits is 1,024. The
maximum key length depends on the algorithm: 16,384 for RSA and 10,000
for DSA. These key-length limits are constraints imposed by OpenSSL.
Server administrators can impose additional limits on maximum key
length by setting environment variables. See
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-usage.html
.
For DH keys, pass a shared DH secret instead of a key length. To create
the secret, pass the key length to create_dh_parameters().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @priv = create_asymmetric_priv_key('DSA', 2048);
SET @pub = create_asymmetric_pub_key('DSA', @priv);
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL 6�@ `�
"� 6|CREATE_ASYMMETRIC_PUB_KEY Syntax:
create_asymmetric_pub_key(algorithm, priv_key_str)
Derives a public key from the given private key using the given
algorithm, and returns the key as a binary string in PEM format. If key
derivation fails, the result is NULL.
priv_key_str must be a valid key string in PEM format. algorithm
indicates the encryption algorithm used to create the key.
Supported algorithm values: 'RSA', 'DSA', 'DH'
For a usage example, see the description of
create_asymmetric_priv_key().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL' �@ h� "� 6�CREATE_DH_PARAMETERS create_dh_parameters(key_len)
Creates a shared secret for generating a DH private/public key pair and
returns a binary string that can be passed to
create_asymmetric_priv_key(). If secret generation fails, the result is
null.
Supported key_len values: The minimum and maximum key lengths in bits
are 1,024 and 10,000. These key-length limits are constraints imposed
by OpenSSL. Server administrators can impose additional limits on
maximum key length by setting environment variables. See
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-usage.html
.
For an example showing how to use the return value for generating
symmetric keys, see the description of asymmetric_derive().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @dhp = create_dh_parameters(1024);
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL:b�@ pE "� 6�CREATE_DIGEST Syntax:
create_digest(digest_type, str)
Creates a digest from the given string using the given digest type, and
returns the digest as a binary string. If digest generation fails, the
result is NULL.
Supported digest_type values: 'SHA224', 'SHA256', 'SHA384', 'SHA512'
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @dig = create_digest('SHA512', The quick brown fox');
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html> �@ x
"� 6�PROCEDURE ANALYSE Syntax:
ANALYSE([max_elements[,max_memory]])
*Note*:
PROCEDURE ANALYSE() is deprecated as of MySQL 5.7.18, and is removed in
MySQL 8.0.
ANALYSE() examines the result from a query and returns an analysis of
the results that suggests optimal data types for each column that may
help reduce table sizes. To obtain this analysis, append PROCEDURE
ANALYSE to the end of a SELECT statement:
SELECT ... FROM ... WHERE ... PROCEDURE ANALYSE([max_elements,[max_memory]])
For example:
SELECT col1, col2 FROM table1 PROCEDURE ANALYSE(10, 2000);
The results show some statistics for the values returned by the query,
and propose an optimal data type for the columns. This can be helpful
for checking your existing tables, or after importing new data. You may
need to try different settings for the arguments so that PROCEDURE
ANALYSE() does not suggest the ENUM data type when it is not
appropriate.
The arguments are optional and are used as follows:
o max_elements (default 256) is the maximum number of distinct values
that ANALYSE() notices per column. This is used by ANALYSE() to check
whether the optimal data type should be of type ENUM; if there are
more than max_elements distinct values, then ENUM is not a suggested
type.
o max_memory (default 8192) is the maximum amount of memory that
ANALYSE() should allocate per column while trying to find all
distinct values.
A PROCEDURE clause is not permitted in a UNION statement.
URL: https://dev.mysql.com/doc/refman/5.7/en/procedure-analyse.html
https://dev.mysql.com/doc/refman/5.7/en/procedure-analyse.html p pj cB�l� >�Fyq� �sE� ;z� 9� infimum supremumL 8�@ � "� 6XASYMMETRIC_SIGN Syntax:
asymmetric_sign(algorithm, digest_str, priv_key_str, digest_type)
Signs a digest string using a private key string, and returns the
signature as a binary string. If signing fails, the result is NULL.
digest_str is the digest string. It can be generated by calling
create_digest(). digest_type indicates the digest algorithm used to
generate the digest string.
priv_key_str is the private key string to use for signing the digest
string. It must be a valid key string in PEM format. algorithm
indicates the encryption algorithm used to create the key.
Supported algorithm values: 'RSA', 'DSA'
Supported digest_type values: 'SHA224', 'SHA256', 'SHA384', 'SHA512'
For a usage example, see the description of asymmetric_verify().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL ���@ Q "� 6dASYMMETRIC_VERIFY Syntax:
asymmetric_verify(algorithm, digest_str, sig_str, pub_key_str,
digest_type)
Verifies whether the signature string matches the digest string, and
returns 1 or 0 to indicate whether verification succeeded or failed.
digest_str is the digest string. It can be generated by calling
create_digest(). digest_type indicates the digest algorithm used to
generate the digest string.
sig_str is the signature string. It can be generated by calling
asymmetric_sign().
pub_key_str is the public key string of the signer. It corresponds to
the private key passed to asymmetric_sign() to generate the signature
string and must be a valid key string in PEM format. algorithm
indicates the encryption algorithm used to create the key.
Supported algorithm values: 'RSA', 'DSA'
Supported digest_type values: 'SHA224', 'SHA256', 'SHA384', 'SHA512'
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
-- Set the encryption algorithm and digest type
SET @algo = 'RSA';
SET @dig_type = 'SHA224';
-- Create private/public key pair
SET @priv = create_asymmetric_priv_key(@algo, 1024);
SET @pub = create_asymmetric_pub_key(@algo, @priv);
-- Generate digest from string
SET @dig = create_digest(@dig_type, 'The quick brown fox');
-- Generate signature for digest and verify signature against digest
SET @sig = asymmetric_sign(@algo, @dig, @priv, @dig_type);
SET @verf = asymmetric_verify(@algo, @dig, @sig, @pub, @dig_type);
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlLi��@ � "� 6pCREATE_ASYMMETRIC_PRIV_KEY Syntax:
create_asymmetric_priv_key(algorithm, {key_len|dh_secret})
Creates a private key using the given algorithm and key length or DH
secret, and returns the key as a binary string in PEM format. If key
generation fails, the result is NULL.
Supported algorithm values: 'RSA', 'DSA', 'DH'
Supported key_len values: The minimum key length in bits is 1,024. The
maximum key length depends on the algorithm: 16,384 for RSA and 10,000
for DSA. These key-length limits are constraints imposed by OpenSSL.
Server administrators can impose additional limits on maximum key
length by setting environment variables. See
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-usage.html
.
For DH keys, pass a shared DH secret instead of a key length. To create
the secret, pass the key length to create_dh_parameters().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @priv = create_asymmetric_priv_key('DSA', 2048);
SET @pub = create_asymmetric_pub_key('DSA', @priv);
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL 6�@ (�
"� 6|CREATE_ASYMMETRIC_PUB_KEY Syntax:
create_asymmetric_pub_key(algorithm, priv_key_str)
Derives a public key from the given private key using the given
algorithm, and returns the key as a binary string in PEM format. If key
derivation fails, the result is NULL.
priv_key_str must be a valid key string in PEM format. algorithm
indicates the encryption algorithm used to create the key.
Supported algorithm values: 'RSA', 'DSA', 'DH'
For a usage example, see the description of
create_asymmetric_priv_key().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL' �@ 0� "� 6�CREATE_DH_PARAMETERS create_dh_parameters(key_len)
Creates a shared secret for generating a DH private/public key pair and
returns a binary string that can be passed to
create_asymmetric_priv_key(). If secret generation fails, the result is
null.
Supported key_len values: The minimum and maximum key lengths in bits
are 1,024 and 10,000. These key-length limits are constraints imposed
by OpenSSL. Server administrators can impose additional limits on
maximum key length by setting environment variables. See
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-usage.html
.
For an example showing how to use the return value for generating
symmetric keys, see the description of asymmetric_derive().
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @dhp = create_dh_parameters(1024);
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlL:b�@ 8E "� 6�CREATE_DIGEST Syntax:
create_digest(digest_type, str)
Creates a digest from the given string using the given digest type, and
returns the digest as a binary string. If digest generation fails, the
result is NULL.
Supported digest_type values: 'SHA224', 'SHA256', 'SHA384', 'SHA512'
URL: https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @dig = create_digest('SHA512', The quick brown fox');
https://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html> �@ @�
"� 6�PROCEDURE ANALYSE Syntax:
ANALYSE([max_elements[,max_memory]])
*Note*:
PROCEDURE ANALYSE() is deprecated as of MySQL 5.7.18, and is removed in
MySQL 8.0.
ANALYSE() examines the result from a query and returns an analysis of
the results that suggests optimal data types for each column that may
help reduce table sizes. To obtain this analysis, append PROCEDURE
ANALYSE to the end of a SELECT statement:
SELECT ... FROM ... WHERE ... PROCEDURE ANALYSE([max_elements,[max_memory]])
For example:
SELECT col1, col2 FROM table1 PROCEDURE ANALYSE(10, 2000);
The results show some statistics for the values returned by the query,
and propose an optimal data type for the columns. This can be helpful
for checking your existing tables, or after importing new data. You may
need to try different settings for the arguments so that PROCEDURE
ANALYSE() does not suggest the ENUM data type when it is not
appropriate.
The arguments are optional and are used as follows:
o max_elements (default 256) is the maximum number of distinct values
that ANALYSE() notices per column. This is used by ANALYSE() to check
whether the optimal data type should be of type ENUM; if there are
more than max_elements distinct values, then ENUM is not a suggested
type.
o max_memory (default 8192) is the maximum amount of memory that
ANALYSE() should allocate per column while trying to find all
distinct values.
A PROCEDURE clause is not permitted in a UNION statement.
URL: https://dev.mysql.com/doc/refman/5.7/en/procedure-analyse.html
https://dev.mysql.com/doc/refman/5.7/en/procedure-analyse.htmlO s�@ H "� 6�FLUSH QUERY CACHE You can defragment the query cache to better utilize its memory with
the FLUSH QUERY CACHE statement. The statement does not remove any
queries from the cache.
The RESET QUERY CACHE statement removes all query results from the
query cache. The FLUSH TABLES statement also does this.
URL: https://dev.mysql.com/doc/refman/5.7/en/query-cache-status-and-maintenance.html
https://dev.mysql.com/doc/refman/5.7/en/query-cache-status-and-maintenance.html= ��@ P� "� 6�TRUE The constants TRUE and FALSE evaluate to 1 and 0, respectively. The
constant names can be written in any lettercase.
mysql> SELECT TRUE, true, FALSE, false;
-> 1, 1, 0, 0
URL: https://dev.mysql.com/doc/refman/5.7/en/boolean-literals.html
https://dev.mysql.com/doc/refman/5.7/en/boolean-literals.html= ��@ X� "� 6�FALSE The constants TRUE and FALSE evaluate to 1 and 0, respectively. The
constant names can be written in any lettercase.
mysql> SELECT TRUE, true, FALSE, false;
-> 1, 1, 0, 0
URL: https://dev.mysql.com/doc/refman/5.7/en/boolean-literals.html
https://dev.mysql.com/doc/refman/5.7/en/boolean-literals.html@ ��@ `[ "� 6�BIT BIT[(M)]
A bit-value type. M indicates the number of bits per value, from 1 to
64. The default is 1 if M is omitted.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ À@ h` "� 6�TINYINT TINYINT[(M)] [UNSIGNED] [ZEROFILL]
A very small integer. The signed range is -128 to 127. The unsigned
range is 0 to 255.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ ��@ p� "� 6�BOOLEAN BOOL, BOOLEAN
These types are synonyms for TINYINT(1). A value of zero is considered
false. Nonzero values are considered true:
mysql> SELECT IF(0, 'true', 'false');
+------------------------+
| IF(0, 'true', 'false') |
+------------------------+
| false |
+------------------------+
mysql> SELECT IF(1, 'true', 'false');
+------------------------+
| IF(1, 'true', 'false') |
+------------------------+
| true |
+------------------------+
mysql> SELECT IF(2, 'true', 'false');
+------------------------+
| IF(2, 'true', 'false') |
+------------------------+
| true |
+------------------------+
However, the values TRUE and FALSE are merely aliases for 1 and 0,
respectively, as shown here:
mysql> SELECT IF(0 = FALSE, 'true', 'false');
+--------------------------------+
| IF(0 = FALSE, 'true', 'false') |
+--------------------------------+
| true |
+--------------------------------+
mysql> SELECT IF(1 = TRUE, 'true', 'false');
+-------------------------------+
| IF(1 = TRUE, 'true', 'false') |
+-------------------------------+
| true |
+-------------------------------+
mysql> SELECT IF(2 = TRUE, 'true', 'false');
+-------------------------------+
| IF(2 = TRUE, 'true', 'false') |
+-------------------------------+
| false |
+-------------------------------+
mysql> SELECT IF(2 = FALSE, 'true', 'false');
+--------------------------------+
| IF(2 = FALSE, 'true', 'false') |
+--------------------------------+
| false |
+--------------------------------+
The last two statements display the results shown because 2 is equal to
neither 1 nor 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ ŀ@ xb "� 6�SMALLINT SMALLINT[(M)] [UNSIGNED] [ZEROFILL]
A small integer. The signed range is -32768 to 32767. The unsigned
range is 0 to 65535.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ Ԁ@ �q "� 6 MEDIUMINT MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL]
A medium-sized integer. The signed range is -8388608 to 8388607. The
unsigned range is 0 to 16777215.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ Հ@ �r "� 6 INT INT[(M)] [UNSIGNED] [ZEROFILL]
A normal-size integer. The signed range is -2147483648 to 2147483647.
The unsigned range is 0 to 4294967295.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ ��@ �) "� 6INTEGER INTEGER[(M)] [UNSIGNED] [ZEROFILL]
This type is a synonym for INT.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ 6�@ �� "� 6$BIGINT BIGINT[(M)] [UNSIGNED] [ZEROFILL]
A large integer. The signed range is -9223372036854775808 to
9223372036854775807. The unsigned range is 0 to 18446744073709551615.
SERIAL is an alias for BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ n�@ � "� 60DECIMAL DECIMAL[(M[,D])] [UNSIGNED] [ZEROFILL]
A packed "exact" fixed-point number. M is the total number of digits
(the precision) and D is the number of digits after the decimal point
(the scale). The decimal point and (for negative numbers) the - sign
are not counted in M. If D is 0, values have no decimal point or
fractional part. The maximum number of digits (M) for DECIMAL is 65.
The maximum number of supported decimals (D) is 30. If D is omitted,
the default is 0. If M is omitted, the default is 10. (There is also a
limit on how long the text of DECIMAL literals can be; see
https://dev.mysql.com/doc/refman/5.7/en/precision-math-expressions.html
.)
UNSIGNED, if specified, disallows negative values.
All basic calculations (+, -, *, /) with DECIMAL columns are done with
a precision of 65 digits.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ .�@ �Ʒ "� 6<DEC DEC[(M[,D])] [UNSIGNED] [ZEROFILL], NUMERIC[(M[,D])] [UNSIGNED]
[ZEROFILL], FIXED[(M[,D])] [UNSIGNED] [ZEROFILL]
These types are synonyms for DECIMAL. The FIXED synonym is available
for compatibility with other database systems.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html p1@%v �Q cFyq� �s�L"� ˬE� :]� 8, infimum supremum@ @ _ "� 6HFLOAT FLOAT[(M,D)] [UNSIGNED] [ZEROFILL]
A small (single-precision) floating-point number. Permissible values
are -3.402823466E+38 to -1.175494351E-38, 0, and 1.175494351E-38 to
3.402823466E+38. These are the theoretical limits, based on the IEEE
standard. The actual range might be slightly smaller depending on your
hardware or operating system.
M is the total number of digits and D is the number of digits following
the decimal point. If M and D are omitted, values are stored to the
limits permitted by the hardware. A single-precision floating-point
number is accurate to approximately 7 decimal places.
FLOAT(M,D) is a nonstandard MySQL extension.
UNSIGNED, if specified, disallows negative values.
Using FLOAT might give you some unexpected problems because all
calculations in MySQL are done with double precision. See
https://dev.mysql.com/doc/refman/5.7/en/no-matching-rows.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ 1�@ � "� 6TDOUBLE DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL]
A normal-size (double-precision) floating-point number. Permissible
values are -1.7976931348623157E+308 to -2.2250738585072014E-308, 0, and
2.2250738585072014E-308 to 1.7976931348623157E+308. These are the
theoretical limits, based on the IEEE standard. The actual range might
be slightly smaller depending on your hardware or operating system.
M is the total number of digits and D is the number of digits following
the decimal point. If M and D are omitted, values are stored to the
limits permitted by the hardware. A double-precision floating-point
number is accurate to approximately 15 decimal places.
DOUBLE(M,D) is a nonstandard MySQL extension.
UNSIGNED, if specified, disallows negative values.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html@ $�@ � "� 6`DOUBLE PRECISION DOUBLE PRECISION[(M,D)] [UNSIGNED] [ZEROFILL], REAL[(M,D)] [UNSIGNED]
[ZEROFILL]
These types are synonyms for DOUBLE. Exception: If the REAL_AS_FLOAT
SQL mode is enabled, REAL is a synonym for FLOAT rather than DOUBLE.
URL: https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/numeric-type-syntax.htmlF �@ (� "� 6lDATE DATE
A date. The supported range is '1000-01-01' to '9999-12-31'. MySQL
displays DATE values in 'YYYY-MM-DD' format, but permits assignment of
values to DATE columns using either strings or numbers.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.htmlF 1�@ 0� "� 6xDATETIME DATETIME[(fsp)]
A date and time combination. The supported range is '1000-01-01
00:00:00.000000' to '9999-12-31 23:59:59.499999'. MySQL displays
DATETIME values in 'YYYY-MM-DD hh:mm:ss[.fraction]' format, but permits
assignment of values to DATETIME columns using either strings or
numbers.
An optional fsp value in the range from 0 to 6 may be given to specify
fractional seconds precision. A value of 0 signifies that there is no
fractional part. If omitted, the default precision is 0.
Automatic initialization and updating to the current date and time for
DATETIME columns can be specified using DEFAULT and ON UPDATE column
definition clauses, as described in
https://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.htmlF 6�@ 8� "� 6�TIMESTAMP TIMESTAMP[(fsp)]
A timestamp. The range is '1970-01-01 00:00:01.000000' UTC to
'2038-01-19 03:14:07.499999' UTC. TIMESTAMP values are stored as the
number of seconds since the epoch ('1970-01-01 00:00:00' UTC). A
TIMESTAMP cannot represent the value '1970-01-01 00:00:00' because that
is equivalent to 0 seconds from the epoch and the value 0 is reserved
for representing '0000-00-00 00:00:00', the "zero" TIMESTAMP value.
An optional fsp value in the range from 0 to 6 may be given to specify
fractional seconds precision. A value of 0 signifies that there is no
fractional part. If omitted, the default precision is 0.
The way the server handles TIMESTAMP definitions depends on the value
of the explicit_defaults_for_timestamp system variable (see
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html).
If explicit_defaults_for_timestamp is enabled, there is no automatic
assignment of the DEFAULT CURRENT_TIMESTAMP or ON UPDATE
CURRENT_TIMESTAMP attributes to any TIMESTAMP column. They must be
included explicitly in the column definition. Also, any TIMESTAMP not
explicitly declared as NOT NULL permits NULL values.
If explicit_defaults_for_timestamp is disabled, the server handles
TIMESTAMP as follows:
Unless specified otherwise, the first TIMESTAMP column in a table is
defined to be automatically set to the date and time of the most recent
modification if not explicitly assigned a value. This makes TIMESTAMP
useful for recording the timestamp of an INSERT or UPDATE operation.
You can also set any TIMESTAMP column to the current date and time by
assigning it a NULL value, unless it has been defined with the NULL
attribute to permit NULL values.
Automatic initialization and updating to the current date and time can
be specified using DEFAULT CURRENT_TIMESTAMP and ON UPDATE
CURRENT_TIMESTAMP column definition clauses. By default, the first
TIMESTAMP column has these properties, as previously noted. However,
any TIMESTAMP column in a table can be defined to have these
properties.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.htmlF �@ @� ! "� 6�TIME TIME[(fsp)]
A time. The range is '-838:59:59.000000' to '838:59:59.000000'. MySQL
displays TIME values in 'hh:mm:ss[.fraction]' format, but permits
assignment of values to TIME columns using either strings or numbers.
An optional fsp value in the range from 0 to 6 may be given to specify
fractional seconds precision. A value of 0 signifies that there is no
fractional part. If omitted, the default precision is 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.htmlF ��@ H, " "� 6�YEAR DATA TYPE YEAR[(4)]
A year in 4-digit format. MySQL displays YEAR values in YYYY format,
but permits assignment of values to YEAR columns using either strings
or numbers. Values display as 1901 to 2155, or 0000.
*Note*:
The YEAR(2) data type is deprecated and support for it is removed in
MySQL 5.7.5. To convert 2-digit YEAR(2) columns to 4-digit YEAR
columns, see
https://dev.mysql.com/doc/refman/5.7/en/migrating-from-year2.html.
For additional information about YEAR display format and interpretation
of input values, see https://dev.mysql.com/doc/refman/5.7/en/year.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html? ߁@ P{ # "� 6�CHAR [NATIONAL] CHAR[(M)] [CHARACTER SET charset_name] [COLLATE
collation_name]
A fixed-length string that is always right-padded with spaces to the
specified length when stored. M represents the column length in
characters. The range of M is 0 to 255. If M is omitted, the length is
1.
*Note*:
Trailing spaces are removed when CHAR values are retrieved unless the
PAD_CHAR_TO_FULL_LENGTH SQL mode is enabled.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ��@ XB $ "� 6�CHAR BYTE The CHAR BYTE data type is an alias for the BINARY data type. This is a
compatibility feature.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? \�@ `� % "� 6�VARCHAR [NATIONAL] VARCHAR(M) [CHARACTER SET charset_name] [COLLATE
collation_name]
A variable-length string. M represents the maximum column length in
characters. The range of M is 0 to 65,535. The effective maximum length
of a VARCHAR is subject to the maximum row size (65,535 bytes, which is
shared among all columns) and the character set used. For example, utf8
characters can require up to three bytes per character, so a VARCHAR
column that uses the utf8 character set can be declared to be a maximum
of 21,844 characters. See
https://dev.mysql.com/doc/refman/5.7/en/column-count-limit.html.
MySQL stores VARCHAR values as a 1-byte or 2-byte length prefix plus
data. The length prefix indicates the number of bytes in the value. A
VARCHAR column uses one length byte if values require no more than 255
bytes, two length bytes if values may require more than 255 bytes.
*Note*:
MySQL follows the standard SQL specification, and does not remove
trailing spaces from VARCHAR values.
VARCHAR is shorthand for CHARACTER VARYING. NATIONAL VARCHAR is the
standard SQL way to define that a VARCHAR column should use some
predefined character set. MySQL uses utf8 as this predefined character
set. https://dev.mysql.com/doc/refman/5.7/en/charset-national.html.
NVARCHAR is shorthand for NATIONAL VARCHAR.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? "�@ h� & "� 6�BINARY BINARY[(M)]
The BINARY type is similar to the CHAR type, but stores binary byte
strings rather than nonbinary character strings. An optional length M
represents the column length in bytes. If omitted, M defaults to 1.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? �@ p� ' "� 6�VARBINARY VARBINARY(M)
The VARBINARY type is similar to the VARCHAR type, but stores binary
byte strings rather than nonbinary character strings. M represents the
maximum column length in bytes.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ��@ x� ( "� 6�TINYBLOB TINYBLOB
A BLOB column with a maximum length of 255 (28 − 1) bytes. Each
TINYBLOB value is stored using a 1-byte length prefix that indicates
the number of bytes in the value.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ��@ �" ) "� 6�TINYTEXT TINYTEXT [CHARACTER SET charset_name] [COLLATE collation_name]
A TEXT column with a maximum length of 255 (28 − 1) characters. The
effective maximum length is less if the value contains multibyte
characters. Each TINYTEXT value is stored using a 1-byte length prefix
that indicates the number of bytes in the value.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ��@ �7 * "� 6�BLOB BLOB[(M)]
A BLOB column with a maximum length of 65,535 (216 − 1) bytes. Each
BLOB value is stored using a 2-byte length prefix that indicates the
number of bytes in the value.
An optional length M can be given for this type. If this is done, MySQL
creates the column as the smallest BLOB type large enough to hold
values M bytes long.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ,�@ �� + "� 6TEXT TEXT[(M)] [CHARACTER SET charset_name] [COLLATE collation_name]
A TEXT column with a maximum length of 65,535 (216 − 1) characters.
The effective maximum length is less if the value contains multibyte
characters. Each TEXT value is stored using a 2-byte length prefix that
indicates the number of bytes in the value.
An optional length M can be given for this type. If this is done, MySQL
creates the column as the smallest TEXT type large enough to hold
values M characters long.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? �@ �� , "� 6MEDIUMBLOB MEDIUMBLOB
A BLOB column with a maximum length of 16,777,215 (224 − 1) bytes.
Each MEDIUMBLOB value is stored using a 3-byte length prefix that
indicates the number of bytes in the value.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ��@ �. - "� 6 MEDIUMTEXT MEDIUMTEXT [CHARACTER SET charset_name] [COLLATE collation_name]
A TEXT column with a maximum length of 16,777,215 (224 − 1)
characters. The effective maximum length is less if the value contains
multibyte characters. Each MEDIUMTEXT value is stored using a 3-byte
length prefix that indicates the number of bytes in the value.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ��@ ��D . "� 6,LONGBLOB LONGBLOB
A BLOB column with a maximum length of 4,294,967,295 or 4GB (232 − 1)
bytes. The effective maximum length of LONGBLOB columns depends on the
configured maximum packet size in the client/server protocol and
available memory. Each LONGBLOB value is stored using a 4-byte length
prefix that indicates the number of bytes in the value.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html p/](Ji
p c�L"� ˬ�ڞ� �E� ;D� 9� infimum supremum? 0�@ � / "� 68LONGTEXT LONGTEXT [CHARACTER SET charset_name] [COLLATE collation_name]
A TEXT column with a maximum length of 4,294,967,295 or 4GB (232 − 1)
characters. The effective maximum length is less if the value contains
multibyte characters. The effective maximum length of LONGTEXT columns
also depends on the configured maximum packet size in the client/server
protocol and available memory. Each LONGTEXT value is stored using a
4-byte length prefix that indicates the number of bytes in the value.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ł@ a 0 "� 6DENUM ENUM('value1','value2',...) [CHARACTER SET charset_name] [COLLATE
collation_name]
An enumeration. A string object that can have only one value, chosen
from the list of values 'value1', 'value2', ..., NULL or the special ''
error value. ENUM values are represented internally as integers.
An ENUM column can have a maximum of 65,535 distinct elements. (The
practical limit is less than 3000.) A table can have no more than 255
unique element list definitions among its ENUM and SET columns
considered as a group. For more information on these limits, see
https://dev.mysql.com/doc/refman/5.7/en/create-table-files.html#limits-
frm-file.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html? ~�@ 1 "� 6PSET DATA TYPE SET('value1','value2',...) [CHARACTER SET charset_name] [COLLATE
collation_name]
A set. A string object that can have zero or more values, each of which
must be chosen from the list of values 'value1', 'value2', ... SET
values are represented internally as integers.
A SET column can have a maximum of 64 distinct members. A table can
have no more than 255 unique element list definitions among its ENUM
and SET columns considered as a group. For more information on this
limit, see
https://dev.mysql.com/doc/refman/5.7/en/create-table-files.html#limits-
frm-file.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html
https://dev.mysql.com/doc/refman/5.7/en/string-type-syntax.html1 ��@ (� 2 "� 6\BLOB DATA TYPE A BLOB is a binary large object that can hold a variable amount of
data. The four BLOB types are TINYBLOB, BLOB, MEDIUMBLOB, and LONGBLOB.
These differ only in the maximum length of the values they can hold.
The four TEXT types are TINYTEXT, TEXT, MEDIUMTEXT, and LONGTEXT. These
correspond to the four BLOB types and have the same maximum lengths and
storage requirements. See
https://dev.mysql.com/doc/refman/5.7/en/storage-requirements.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/blob.html
https://dev.mysql.com/doc/refman/5.7/en/blob.htmlI �@ 0� 3 "� 6hGEOMETRY HIERARCHY Geometry is the base class. It is an abstract class. The instantiable
subclasses of Geometry are restricted to zero-, one-, and
two-dimensional geometric objects that exist in two-dimensional
coordinate space. All instantiable geometry classes are defined so that
valid instances of a geometry class are topologically closed (that is,
all defined geometries include their boundary).
The base Geometry class has subclasses for Point, Curve, Surface, and
GeometryCollection:
o Point represents zero-dimensional objects.
o Curve represents one-dimensional objects, and has subclass
LineString, with sub-subclasses Line and LinearRing.
o Surface is designed for two-dimensional objects and has subclass
Polygon.
o GeometryCollection has specialized zero-, one-, and two-dimensional
collection classes named MultiPoint, MultiLineString, and
MultiPolygon for modeling geometries corresponding to collections of
Points, LineStrings, and Polygons, respectively. MultiCurve and
MultiSurface are introduced as abstract superclasses that generalize
the collection interfaces to handle Curves and Surfaces.
Geometry, Curve, Surface, MultiCurve, and MultiSurface are defined as
noninstantiable classes. They define a common set of methods for their
subclasses and are included for extensibility.
Point, LineString, Polygon, GeometryCollection, MultiPoint,
MultiLineString, and MultiPolygon are instantiable classes.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-geometry-class-hierarchy.html
https://dev.mysql.com/doc/refman/5.7/en/gis-geometry-class-hierarchy.html?:@ 8� 4 "� 6tMBR DEFINITION Its MBR (minimum bounding rectangle), or envelope. This is the bounding
geometry, formed by the minimum and maximum (X,Y) coordinates:
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-class-geometry.html
((MINX MINY, MAXX MINY, MAXX MAXY, MINX MAXY, MINX MINY))
https://dev.mysql.com/doc/refman/5.7/en/gis-class-geometry.html= v�@ @ 5 "� 6�WKT DEFINITION
The Well-Known Text (WKT) representation of geometry values is designed
for exchanging geometry data in ASCII form. The OpenGIS specification
provides a Backus-Naur grammar that specifies the formal production
rules for writing WKT values (see
https://dev.mysql.com/doc/refman/5.7/en/spatial-types.html).
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-data-formats.html
https://dev.mysql.com/doc/refman/5.7/en/gis-data-formats.htmlE \�@ H 6 "� 6�SPATIAL COLUMNS MySQL provides a standard way of creating spatial columns for geometry
types, for example, with CREATE TABLE or ALTER TABLE. Spatial columns
are supported for MyISAM, InnoDB, NDB, and ARCHIVE tables. See also the
notes about spatial indexes under [HELP SPATIAL indexes].
URL: https://dev.mysql.com/doc/refman/5.7/en/creating-spatial-columns.html
CREATE TABLE geom (g GEOMETRY);
https://dev.mysql.com/doc/refman/5.7/en/creating-spatial-columns.htmlE �@ P� 7 "� 6�SPATIAL INDEXES For InnoDB and MyISAM tables, MySQL can create spatial indexes using
syntax similar to that for creating regular indexes, but using the
SPATIAL keyword. Columns in spatial indexes must be declared NOT NULL.
The following examples demonstrate how to create spatial indexes:
o With CREATE TABLE:
CREATE TABLE geom (g GEOMETRY NOT NULL, SPATIAL INDEX(g));
o With ALTER TABLE:
CREATE TABLE geom (g GEOMETRY NOT NULL);
ALTER TABLE geom ADD SPATIAL INDEX(g);
o With CREATE INDEX:
CREATE TABLE geom (g GEOMETRY NOT NULL);
CREATE SPATIAL INDEX g ON geom (g);
SPATIAL INDEX creates an R-tree index. For storage engines that support
nonspatial indexing of spatial columns, the engine creates a B-tree
index. A B-tree index on spatial values is useful for exact-value
lookups, but not for range scans.
For more information on indexing spatial columns, see [HELP CREATE
INDEX].
To drop spatial indexes, use ALTER TABLE or DROP INDEX:
o With ALTER TABLE:
ALTER TABLE geom DROP INDEX g;
o With DROP INDEX:
DROP INDEX g ON geom;
Example: Suppose that a table geom contains more than 32,000
geometries, which are stored in the column g of type GEOMETRY. The
table also has an AUTO_INCREMENT column fid for storing object ID
values.
URL: https://dev.mysql.com/doc/refman/5.7/en/creating-spatial-indexes.html
https://dev.mysql.com/doc/refman/5.7/en/creating-spatial-indexes.htmlA��S@ X� 8 "� 6�= =
Equal:
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 1 = 0;
-> 0
mysql> SELECT '0' = 0;
-> 1
mysql> SELECT '0.0' = 0;
-> 1
mysql> SELECT '0.01' = 0;
-> 0
mysql> SELECT '.01' = 0.01;
-> 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA��f�@ `� 9 "� 6�<=> Syntax:
<=>
NULL-safe equal. This operator performs an equality comparison like the
= operator, but returns 1 rather than NULL if both operands are NULL,
and 0 rather than NULL if one operand is NULL.
The <=> operator is equivalent to the standard SQL IS NOT DISTINCT FROM
operator.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
-> 1, 1, 0
mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;
-> 1, NULL, NULL
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA��d@ h� : "� 6�!= Syntax:
<>, !=
Not equal:
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT '.01' <> '0.01';
-> 1
mysql> SELECT .01 <> '0.01';
-> 0
mysql> SELECT 'zapp' <> 'zappp';
-> 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA%i@ p+ ; "� 6�<= Syntax:
<=
Less than or equal:
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 0.1 <= 2;
-> 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA"_@ x < "� 6�< Syntax:
<
Less than:
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 < 2;
-> 0
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA#l@ �, = "� 6�>= Syntax:
>=
Greater than or equal:
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 >= 2;
-> 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA"b@ �# > "� 6�> Syntax:
>
Greater than:
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 > 2;
-> 0
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA��@ �� ? "� 6�BETWEEN AND Syntax:
expr BETWEEN min AND max
If expr is greater than or equal to min and expr is less than or equal
to max, BETWEEN returns 1, otherwise it returns 0. This is equivalent
to the expression (min <= expr AND expr <= max) if all the arguments
are of the same type. Otherwise type conversion takes place according
to the rules described in
https://dev.mysql.com/doc/refman/5.7/en/type-conversion.html, but
applied to all the three arguments.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 BETWEEN 1 AND 3, 2 BETWEEN 3 and 1;
-> 1, 0
mysql> SELECT 1 BETWEEN 2 AND 3;
-> 0
mysql> SELECT 'b' BETWEEN 'a' AND 'c';
-> 1
mysql> SELECT 2 BETWEEN 2 AND '3';
-> 1
mysql> SELECT 2 BETWEEN 2 AND 'x-3';
-> 0
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA ��@ �A @ "� 6NOT BETWEEN Syntax:
expr NOT BETWEEN min AND max
This is the same as NOT (expr BETWEEN min AND max).
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlAe
�@ � A "� 6COALESCE Syntax:
COALESCE(value,...)
Returns the first non-NULL value in the list, or NULL if there are no
non-NULL values.
The return type of COALESCE() is the aggregated type of the argument
types.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT COALESCE(NULL,1);
-> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA����@ �2 B "� 6 GREATEST Syntax:
GREATEST(value1,value2,...)
With two or more arguments, returns the largest (maximum-valued)
argument. The arguments are compared using the same rules as for
LEAST().
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT GREATEST(2,0);
-> 2
mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
-> 767.0
mysql> SELECT GREATEST('B','A','C');
-> 'C'
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlAhӂ@ �� C "� 6(IN Syntax:
expr IN (value,...)
Returns 1 (true) if expr is equal to any of the values in the IN()
list, else returns 0 (false).
Type conversion takes place according to the rules described in
https://dev.mysql.com/doc/refman/5.7/en/type-conversion.html, applied
to all the arguments. If no type conversion is needed for the values in
the IN() list, they are all constants of the same type, and expr can be
compared to each of them as a value of the same type (possibly after
type conversion), an optimization takes place. The values the list are
sorted and the search for expr is done using a binary search, which
makes the IN() operation very quick.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 IN (0,3,5,7);
-> 0
mysql> SELECT 'wefwf' IN ('wee','wefwf','weg');
-> 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA ��@ �8 D "� 64NOT IN Syntax:
expr NOT IN (value,...)
This is the same as NOT (expr IN (value,...)).
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA��^�@ �� E "� 6@INTERVAL Syntax:
INTERVAL(N,N1,N2,N3,...)
Returns 0 if N <= N1, 1 if N <= N2 and so on, or -1 if N is NULL. All
arguments are treated as integers. It is required that N1 <= N2 <= N3
<= ... <= Nn for this function to work correctly. This is because a
binary search is used (very fast).
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
-> 3
mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
-> 2
mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
-> 0
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlAI��@ ��� F "� 6LIS Syntax:
IS boolean_value
Tests a value against a boolean value, where boolean_value can be TRUE,
FALSE, or UNKNOWN.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;
-> 1, 1, 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html p/�'�"�� � c�ڞ� ���+�
\�E� :a� 83 infimum supremumAZ@ � G "� 6XIS NOT Syntax:
IS NOT boolean_value
Tests a value against a boolean value, where boolean_value can be TRUE,
FALSE, or UNKNOWN.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 1 IS NOT UNKNOWN, 0 IS NOT UNKNOWN, NULL IS NOT UNKNOWN;
-> 1, 1, 0
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlAEy@ \ H "� 6dIS NULL Syntax:
IS NULL
Tests whether a value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
-> 0, 0, 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlAQ��@ p I "� 6pIS NOT NULL Syntax:
IS NOT NULL
Tests whether a value is not NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
-> 1, 1, 0
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlAP��@ (� J "� 6|ISNULL Syntax:
ISNULL(expr)
If expr is NULL, ISNULL() returns 1, otherwise it returns 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT ISNULL(1+1);
-> 0
mysql> SELECT ISNULL(1/0);
-> 1
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA����@ 0� K "� 6�LEAST Syntax:
LEAST(value1,value2,...)
With two or more arguments, returns the smallest (minimum-valued)
argument. The arguments are compared using the following rules:
o If any argument is NULL, the result is NULL. No comparison is needed.
o If all arguments are integer-valued, they are compared as integers.
o If at least one argument is double precision, they are compared as
double-precision values. Otherwise, if at least one argument is a
DECIMAL value, they are compared as DECIMAL values.
o If the arguments comprise a mix of numbers and strings, they are
compared as numbers.
o If any argument is a nonbinary (character) string, the arguments are
compared as nonbinary strings.
o In all other cases, the arguments are compared as binary strings.
The return type of LEAST() is the aggregated type of the comparison
argument types.
URL: https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT LEAST(2,0);
-> 0
mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
-> 3.0
mysql> SELECT LEAST('B','A','C');
-> 'A'
https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html>��@ 8 L "� 6�! Syntax:
NOT, !
Logical NOT. Evaluates to 1 if the operand is 0, to 0 if the operand is
nonzero, and NOT NULL returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/logical-operators.html
mysql> SELECT NOT 10;
-> 0
mysql> SELECT NOT 0;
-> 1
mysql> SELECT NOT NULL;
-> NULL
mysql> SELECT ! (1+1);
-> 0
mysql> SELECT ! 1+1;
-> 1
https://dev.mysql.com/doc/refman/5.7/en/logical-operators.html>��݀@ @9 M "� 6�AND Syntax:
AND, &&
Logical AND. Evaluates to 1 if all operands are nonzero and not NULL,
to 0 if one or more operands are 0, otherwise NULL is returned.
URL: https://dev.mysql.com/doc/refman/5.7/en/logical-operators.html
mysql> SELECT 1 AND 1;
-> 1
mysql> SELECT 1 AND 0;
-> 0
mysql> SELECT 1 AND NULL;
-> NULL
mysql> SELECT 0 AND NULL;
-> 0
mysql> SELECT NULL AND 0;
-> 0
https://dev.mysql.com/doc/refman/5.7/en/logical-operators.html>��H�@ H� N "� 6�OR Syntax:
OR, ||
Logical OR. When both operands are non-NULL, the result is 1 if any
operand is nonzero, and 0 otherwise. With a NULL operand, the result is
1 if the other operand is nonzero, and NULL otherwise. If both operands
are NULL, the result is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/logical-operators.html
mysql> SELECT 1 OR 1;
-> 1
mysql> SELECT 1 OR 0;
-> 1
mysql> SELECT 0 OR 0;
-> 0
mysql> SELECT 0 OR NULL;
-> NULL
mysql> SELECT 1 OR NULL;
-> 1
https://dev.mysql.com/doc/refman/5.7/en/logical-operators.html>���@ P( O "� 6�XOR Syntax:
XOR
Logical XOR. Returns NULL if either operand is NULL. For non-NULL
operands, evaluates to 1 if an odd number of operands is nonzero,
otherwise 0 is returned.
URL: https://dev.mysql.com/doc/refman/5.7/en/logical-operators.html
mysql> SELECT 1 XOR 1;
-> 0
mysql> SELECT 1 XOR 0;
-> 1
mysql> SELECT 1 XOR NULL;
-> NULL
mysql> SELECT 1 XOR 1 XOR 1;
-> 1
https://dev.mysql.com/doc/refman/5.7/en/logical-operators.htmlAM��@ X� P "� 6�ASSIGN-VALUE Syntax:
:=
Assignment operator. Causes the user variable on the left hand side of
the operator to take on the value to its right. The value on the right
hand side may be a literal value, another variable storing a value, or
any legal expression that yields a scalar value, including the result
of a query (provided that this value is a scalar value). You can
perform multiple assignments in the same SET statement. You can perform
multiple assignments in the same statement.
Unlike =, the := operator is never interpreted as a comparison
operator. This means you can use := in any valid SQL statement (not
just in SET statements) to assign a value to a variable.
URL: https://dev.mysql.com/doc/refman/5.7/en/assignment-operators.html
mysql> SELECT @var1, @var2;
-> NULL, NULL
mysql> SELECT @var1 := 1, @var2;
-> 1, NULL
mysql> SELECT @var1, @var2;
-> 1, NULL
mysql> SELECT @var1, @var2 := @var1;
-> 1, 1
mysql> SELECT @var1, @var2;
-> 1, 1
mysql> SELECT @var1:=COUNT(*) FROM t1;
-> 4
mysql> SELECT @var1;
-> 4
https://dev.mysql.com/doc/refman/5.7/en/assignment-operators.htmlA��s�@ ` Q "� 6�ASSIGN-EQUAL Syntax:
=
This operator is used to perform value assignments in two cases,
described in the next two paragraphs.
Within a SET statement, = is treated as an assignment operator that
causes the user variable on the left hand side of the operator to take
on the value to its right. (In other words, when used in a SET
statement, = is treated identically to :=.) The value on the right hand
side may be a literal value, another variable storing a value, or any
legal expression that yields a scalar value, including the result of a
query (provided that this value is a scalar value). You can perform
multiple assignments in the same SET statement.
In the SET clause of an UPDATE statement, = also acts as an assignment
operator; in this case, however, it causes the column named on the left
hand side of the operator to assume the value given to the right,
provided any WHERE conditions that are part of the UPDATE are met. You
can make multiple assignments in the same SET clause of an UPDATE
statement.
In any other context, = is treated as a comparison operator.
URL: https://dev.mysql.com/doc/refman/5.7/en/assignment-operators.html
mysql> SELECT @var1, @var2;
-> NULL, NULL
mysql> SELECT @var1 := 1, @var2;
-> 1, NULL
mysql> SELECT @var1, @var2;
-> 1, NULL
mysql> SELECT @var1, @var2 := @var1;
-> 1, 1
mysql> SELECT @var1, @var2;
-> 1, 1
https://dev.mysql.com/doc/refman/5.7/en/assignment-operators.htmlC���@ hH R "� 6�CASE OPERATOR
Syntax:
CASE value WHEN compare_value THEN result [WHEN compare_value THEN
result ...] [ELSE result] END
CASE WHEN condition THEN result [WHEN condition THEN result ...] [ELSE
result] END
The first CASE syntax returns the result for the first
value=compare_value comparison that is true. The second syntax returns
the result for the first condition that is true. If no comparison or
condition is true, the result after ELSE is returned, or NULL if there
is no ELSE part.
*Note*:
The syntax of the CASE operator described here differs slightly from
that of the SQL CASE statement described in [HELP CASE statement], for
use inside stored programs. The CASE statement cannot have an ELSE NULL
clause, and it is terminated with END CASE instead of END.
The return type of a CASE expression result is the aggregated type of
all result values.
URL: https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.html
mysql> SELECT CASE 1 WHEN 1 THEN 'one'
-> WHEN 2 THEN 'two' ELSE 'more' END;
-> 'one'
mysql> SELECT CASE WHEN 1>0 THEN 'true' ELSE 'false' END;
-> 'true'
mysql> SELECT CASE BINARY 'B'
-> WHEN 'a' THEN 1 WHEN 'b' THEN 2 END;
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.htmlC����@ p� S "� 6�IF FUNCTION
Syntax:
IF(expr1,expr2,expr3)
If expr1 is TRUE (expr1 <> 0 and expr1 IS NOT NULL), IF() returns
expr2. Otherwise, it returns expr3.
*Note*:
There is also an IF statement, which differs from the IF() function
described here. See [HELP IF statement].
If only one of expr2 or expr3 is explicitly NULL, the result type of
the IF() function is the type of the non-NULL expression.
The default return type of IF() (which may matter when it is stored
into a temporary table) is calculated as follows:
o If expr2 or expr3 produce a string, the result is a string.
If expr2 and expr3 are both strings, the result is case-sensitive if
either string is case-sensitive.
o If expr2 or expr3 produce a floating-point value, the result is a
floating-point value.
o If expr2 or expr3 produce an integer, the result is an integer.
URL: https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.html
mysql> SELECT IF(1>2,2,3);
-> 3
mysql> SELECT IF(1<2,'yes','no');
-> 'yes'
mysql> SELECT IF(STRCMP('test','test1'),'no','yes');
-> 'no'
https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.htmlC����@ x T "� 6�IFNULL
Syntax:
IFNULL(expr1,expr2)
If expr1 is not NULL, IFNULL() returns expr1; otherwise it returns
expr2.
URL: https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.html
mysql> SELECT IFNULL(1,0);
-> 1
mysql> SELECT IFNULL(NULL,10);
-> 10
mysql> SELECT IFNULL(1/0,10);
-> 10
mysql> SELECT IFNULL(1/0,'yes');
-> 'yes'
https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.htmlCS)�@ � U "� 6NULLIF
Syntax:
NULLIF(expr1,expr2)
Returns NULL if expr1 = expr2 is true, otherwise returns expr1. This is
the same as CASE WHEN expr1 = expr2 THEN NULL ELSE expr1 END.
The return value has the same type as the first argument.
URL: https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.html
mysql> SELECT NULLIF(1,1);
-> NULL
mysql> SELECT NULLIF(1,2);
-> 1
https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.htmlA ^@ � V "� 6+ Syntax:
+
Addition:
URL: https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 3+5;
-> 8
https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlA!a@ � W "� 6!- BINARY Syntax:
-
Subtraction:
URL: https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 3-5;
-> -2
https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlA!��@ �O X "� 6.- UNARY Syntax:
-
Unary minus. This operator changes the sign of the operand.
URL: https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT - 2;
-> -2
https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlAրd@ �� Y "� 6;* Syntax:
*
Multiplication:
URL: https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 3*5;
-> 15
mysql> SELECT 18014398509481984*18014398509481984.0;
-> 324518553658426726783156020576256.0
mysql> SELECT 18014398509481984*18014398509481984;
-> out-of-range error
https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlA#^@ � Z "� 6H/ Syntax:
/
Division:
URL: https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 3/5;
-> 0.60
https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlAN��@ � [ "� 6UDIV Syntax:
DIV
Integer division. Discards from the division result any fractional part
to the right of the decimal point.
If either operand has a noninteger type, the operands are converted to
DECIMAL and divided using DECIMAL arithmetic before converting the
result to BIGINT. If the result exceeds BIGINT range, an error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 5 DIV 2, -5 DIV 2, 5 DIV -2, -5 DIV -2;
-> 2, -2, -2, 2
https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlA %�@ �� \ "� 6b% Syntax:
N % M, N MOD M
Modulo operation. Returns the remainder of N divided by M. For more
information, see the description for the MOD() function in
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
https://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlCIO�@ ��= ] "� 6oABS Syntax:
ABS(X)
Returns the absolute value of X, or NULL if X is NULL.
The result type is derived from the argument type. An implication of
this is that ABS(-9223372036854775808) produces an error because the
result cannot be stored in a signed BIGINT value.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ABS(2);
-> 2
mysql> SELECT ABS(-32);
-> 32
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html p-q @� c��+� \�yw�
��E� :� 9 infimum supremumC��@ � ^ "� 6|ACOS Syntax:
ACOS(X)
Returns the arc cosine of X, that is, the value whose cosine is X.
Returns NULL if X is not in the range -1 to 1.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ACOS(1);
-> 0
mysql> SELECT ACOS(1.0001);
-> NULL
mysql> SELECT ACOS(0);
-> 1.5707963267949
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC �ʀ@ v _ "� 6�ASIN Syntax:
ASIN(X)
Returns the arc sine of X, that is, the value whose sine is X. Returns
NULL if X is not in the range -1 to 1.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ASIN(0.2);
-> 0.20135792079033
mysql> SELECT ASIN('foo');
+-------------+
| ASIN('foo') |
+-------------+
| 0 |
+-------------+
1 row in set, 1 warning (0.00 sec)
mysql> SHOW WARNINGS;
+---------+------+-----------------------------------------+
| Level | Code | Message |
+---------+------+-----------------------------------------+
| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |
+---------+------+-----------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCf��@ � ` "� 6�ATAN Syntax:
ATAN(X)
Returns the arc tangent of X, that is, the value whose tangent is X.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ATAN(2);
-> 1.1071487177941
mysql> SELECT ATAN(-2);
-> -1.1071487177941
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCo1�@ (? a "� 6�ATAN2 Syntax:
ATAN(Y,X), ATAN2(Y,X)
Returns the arc tangent of the two variables X and Y. It is similar to
calculating the arc tangent of Y / X, except that the signs of both
arguments are used to determine the quadrant of the result.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ATAN(-2,2);
-> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
-> 1.5707963267949
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC @ 0 b "� 6�CEIL Syntax:
CEIL(X)
CEIL() is a synonym for CEILING().
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCV��@ 8� c "� 6�CEILING Syntax:
CEILING(X)
Returns the smallest integer value not less than X.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT CEILING(1.23);
-> 2
mysql> SELECT CEILING(-1.23);
-> -1
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCB�@ @� d "� 6�CONV Syntax:
CONV(N,from_base,to_base)
Converts numbers between different number bases. Returns a string
representation of the number N, converted from base from_base to base
to_base. Returns NULL if any argument is NULL. The argument N is
interpreted as an integer, but may be specified as an integer or a
string. The minimum base is 2 and the maximum base is 36. If from_base
is a negative number, N is regarded as a signed number. Otherwise, N is
treated as unsigned. CONV() works with 64-bit precision.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT CONV('a',16,2);
-> '1010'
mysql> SELECT CONV('6E',18,8);
-> '172'
mysql> SELECT CONV(-17,10,-18);
-> '-H'
mysql> SELECT CONV(10+'10'+'10'+X'0a',10,10);
-> '40'
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC'��@ HW e "� 6�COS Syntax:
COS(X)
Returns the cosine of X, where X is given in radians.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT COS(PI());
-> -1
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCgw@ P~ f "� 6�COT Syntax:
COT(X)
Returns the cotangent of X.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT COT(12);
-> -1.5726734063977
mysql> SELECT COT(0);
-> out-of-range error
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCh4�@ X< g "� 6�CRC32 Syntax:
CRC32(expr)
Computes a cyclic redundancy check value and returns a 32-bit unsigned
value. The result is NULL if the argument is NULL. The argument is
expected to be a string and (if possible) is treated as one if it is
not.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT CRC32('MySQL');
-> 3259397556
mysql> SELECT CRC32('mysql');
-> 2501908538
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC[��@ `� h "� 6�DEGREES Syntax:
DEGREES(X)
Returns the argument X, converted from radians to degrees.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT DEGREES(PI());
-> 180
mysql> SELECT DEGREES(PI() / 2);
-> 90
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC����@ h" i "� 6 EXP Syntax:
EXP(X)
Returns the value of e (the base of natural logarithms) raised to the
power of X. The inverse of this function is LOG() (using a single
argument only) or LN().
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT EXP(2);
-> 7.3890560989307
mysql> SELECT EXP(-2);
-> 0.13533528323661
mysql> SELECT EXP(0);
-> 1
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC:��@ pm j "� 6FLOOR Syntax:
FLOOR(X)
Returns the largest integer value not greater than X.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT FLOOR(1.23), FLOOR(-1.23);
-> 1, -2
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCW �@ x k "� 6%LN Syntax:
LN(X)
Returns the natural logarithm of X; that is, the base-e logarithm of X.
If X is less than or equal to 0.0E0, the function returns NULL and a
warning "Invalid argument for logarithm" is reported.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT LN(2);
-> 0.69314718055995
mysql> SELECT LN(-2);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCY��@ �� l "� 62LOG Syntax:
LOG(X), LOG(B,X)
If called with one parameter, this function returns the natural
logarithm of X. If X is less than or equal to 0.0E0, the function
returns NULL and a warning "Invalid argument for logarithm" is
reported.
The inverse of this function (when called with a single argument) is
the EXP() function.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT LOG(2);
-> 0.69314718055995
mysql> SELECT LOG(-2);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCS��@ �� m "� 6?LOG2 Syntax:
LOG2(X)
Returns the base-2 logarithm of X. If X is less than or equal to 0.0E0,
the function returns NULL and a warning "Invalid argument for
logarithm" is reported.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT LOG2(65536);
-> 16
mysql> SELECT LOG2(-100);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC����@ �# n "� 6LLOG10 Syntax:
LOG10(X)
Returns the base-10 logarithm of X. If X is less than or equal to
0.0E0, the function returns NULL and a warning "Invalid argument for
logarithm" is reported.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT LOG10(2);
-> 0.30102999566398
mysql> SELECT LOG10(100);
-> 2
mysql> SELECT LOG10(-100);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC����@ �� o "� 6YMOD Syntax:
MOD(N,M), N % M, N MOD M
Modulo operation. Returns the remainder of N divided by M.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT MOD(234, 10);
-> 4
mysql> SELECT 253 % 7;
-> 1
mysql> SELECT MOD(29,9);
-> 2
mysql> SELECT 29 MOD 9;
-> 2
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCq��@ � p "� 6fPI Syntax:
PI()
Returns the value of π (pi). The default number of decimal places
displayed is seven, but MySQL uses the full double-precision value
internally.
Because the return value of this function is a double-precision value,
its exact representation may vary between platforms or implementations.
This also applies to any expressions making use of PI(). See
https://dev.mysql.com/doc/refman/5.7/en/floating-point-types.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT PI();
-> 3.141593
mysql> SELECT PI()+0.000000000000000000;
-> 3.141592653589793000
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCN��@ �{ q "� 6sPOW Syntax:
POW(X,Y)
Returns the value of X raised to the power of Y.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT POW(2,2);
-> 4
mysql> SELECT POW(2,-2);
-> 0.25
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC |@ � r "� 6�POWER Syntax:
POWER(X,Y)
This is a synonym for POW().
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC6ŀ@ �� s "� 6�RADIANS Syntax:
RADIANS(X)
Returns the argument X, converted from degrees to radians. (Note that
π radians equals 180 degrees.)
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT RADIANS(90);
-> 1.5707963267949
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC���@ � F t "� 6�RAND Syntax:
RAND([N])
Returns a random floating-point value v in the range 0 <= v < 1.0. To
obtain a random integer R in the range i <= R < j, use the expression
FLOOR(i + RAND() * (j − i)). For example, to obtain a random integer
in the range the range 7 <= R < 12, use the following statement:
SELECT FLOOR(7 + (RAND() * 5));
If an integer argument N is specified, it is used as the seed value:
o With a constant initializer argument, the seed is initialized once
when the statement is prepared, prior to execution.
o With a nonconstant initializer argument (such as a column name), the
seed is initialized with the value for each invocation of RAND().
One implication of this behavior is that for equal argument values,
RAND(N) returns the same value each time, and thus produces a
repeatable sequence of column values. In the following example, the
sequence of values produced by RAND(3) is the same both places it
occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> CREATE TABLE t (i INT);
Query OK, 0 rows affected (0.42 sec)
mysql> INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT i, RAND() FROM t;
+------+------------------+
| i | RAND() |
+------+------------------+
| 1 | 0.61914388706828 |
| 2 | 0.93845168309142 |
| 3 | 0.83482678498591 |
+------+------------------+
3 rows in set (0.00 sec)
mysql> SELECT i, RAND(3) FROM t;
+------+------------------+
| i | RAND(3) |
+------+------------------+
| 1 | 0.90576975597606 |
| 2 | 0.37307905813035 |
| 3 | 0.14808605345719 |
+------+------------------+
3 rows in set (0.00 sec)
mysql> SELECT i, RAND() FROM t;
+------+------------------+
| i | RAND() |
+------+------------------+
| 1 | 0.35877890638893 |
| 2 | 0.28941420772058 |
| 3 | 0.37073435016976 |
+------+------------------+
3 rows in set (0.00 sec)
mysql> SELECT i, RAND(3) FROM t;
+------+------------------+
| i | RAND(3) |
+------+------------------+
| 1 | 0.90576975597606 |
| 2 | 0.37307905813035 |
| 3 | 0.14808605345719 |
+------+------------------+
3 rows in set (0.01 sec)
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCp���@ �� u "� 6�ROUND Syntax:
ROUND(X), ROUND(X,D)
Rounds the argument X to D decimal places. The rounding algorithm
depends on the data type of X. D defaults to 0 if not specified. D can
be negative to cause D digits left of the decimal point of the value X
to become zero. The maximum absolute value for D is 30; any digits in
excess of 30 (or -30) are truncated.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ROUND(-1.23);
-> -1
mysql> SELECT ROUND(-1.58);
-> -2
mysql> SELECT ROUND(1.58);
-> 2
mysql> SELECT ROUND(1.298, 1);
-> 1.3
mysql> SELECT ROUND(1.298, 0);
-> 1
mysql> SELECT ROUND(23.298, -1);
-> 20
mysql> SELECT ROUND(.12345678901234567890123456789012345, 35);
-> 0.123456789012345678901234567890
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCqĀ@ ��P v "� 6�SIGN Syntax:
SIGN(X)
Returns the sign of the argument as -1, 0, or 1, depending on whether X
is negative, zero, or positive.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT SIGN(-32);
-> -1
mysql> SELECT SIGN(0);
-> 0
mysql> SELECT SIGN(234);
-> 1
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html p'� ��)� c�yw� ���
&
�?E� 6�� 52 infimum supremumCe��@ � w "� 6�SIN Syntax:
SIN(X)
Returns the sine of X, where X is given in radians.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT SIN(PI());
-> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
-> 0
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC����@ � x "� 6�SQRT Syntax:
SQRT(X)
Returns the square root of a nonnegative number X.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT SQRT(4);
-> 2
mysql> SELECT SQRT(20);
-> 4.4721359549996
mysql> SELECT SQRT(-16);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCo��@ � y "� 6�TAN Syntax:
TAN(X)
Returns the tangent of X, where X is given in radians.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT TAN(PI());
-> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
-> 1.5574077246549
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC"�3�@ (� z "� 6�TRUNCATE Syntax:
TRUNCATE(X,D)
Returns the number X, truncated to D decimal places. If D is 0, the
result has no decimal point or fractional part. D can be negative to
cause D digits left of the decimal point of the value X to become zero.
URL: https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT TRUNCATE(1.223,1);
-> 1.2
mysql> SELECT TRUNCATE(1.999,1);
-> 1.9
mysql> SELECT TRUNCATE(1.999,0);
-> 1
mysql> SELECT TRUNCATE(-1.999,1);
-> -1.9
mysql> SELECT TRUNCATE(122,-2);
-> 100
mysql> SELECT TRUNCATE(10.28*100,0);
-> 1028
https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlDAÂ@ 0� { "� 6�ADDDATE Syntax:
ADDDATE(date,INTERVAL expr unit), ADDDATE(expr,days)
When invoked with the INTERVAL form of the second argument, ADDDATE()
is a synonym for DATE_ADD(). The related function SUBDATE() is a
synonym for DATE_SUB(). For information on the INTERVAL unit argument,
see
https://dev.mysql.com/doc/refman/5.7/en/expressions.html#temporal-inter
vals.
mysql> SELECT DATE_ADD('2008-01-02', INTERVAL 31 DAY);
-> '2008-02-02'
mysql> SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY);
-> '2008-02-02'
When invoked with the days form of the second argument, MySQL treats it
as an integer number of days to be added to expr.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT ADDDATE('2008-01-02', 31);
-> '2008-02-02'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDɀ�@ 8S | "� 6 ADDTIME Syntax:
ADDTIME(expr1,expr2)
ADDTIME() adds expr2 to expr1 and returns the result. expr1 is a time
or datetime expression, and expr2 is a time expression.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT ADDTIME('2007-12-31 23:59:59.999999', '1 1:1:1.000002');
-> '2008-01-02 01:01:01.000001'
mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');
-> '03:00:01.999997'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD��@ @ } "� 6 CONVERT_TZ Syntax:
CONVERT_TZ(dt,from_tz,to_tz)
CONVERT_TZ() converts a datetime value dt from the time zone given by
from_tz to the time zone given by to_tz and returns the resulting
value. Time zones are specified as described in
https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html. This
function returns NULL if the arguments are invalid.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
-> '2004-01-01 13:00:00'
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
-> '2004-01-01 22:00:00'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDb�@ H� ~ "� 6 CURDATE Syntax:
CURDATE()
Returns the current date as a value in 'YYYY-MM-DD' or YYYYMMDD format,
depending on whether the function is used in string or numeric context.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT CURDATE();
-> '2008-06-13'
mysql> SELECT CURDATE() + 0;
-> 20080613
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ PO "� 6 )CURRENT_DATE Syntax:
CURRENT_DATE, CURRENT_DATE()
CURRENT_DATE and CURRENT_DATE() are synonyms for CURDATE().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ XT � "� 6 6CURRENT_TIME Syntax:
CURRENT_TIME, CURRENT_TIME([fsp])
CURRENT_TIME and CURRENT_TIME() are synonyms for CURTIME().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD À@ `d � "� 6 CCURRENT_TIMESTAMP Syntax:
CURRENT_TIMESTAMP, CURRENT_TIMESTAMP([fsp])
CURRENT_TIMESTAMP and CURRENT_TIMESTAMP() are synonyms for NOW().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDe��@ h� � "� 6 PCURTIME Syntax:
CURTIME([fsp])
Returns the current time as a value in 'hh:mm:ss' or hhmmss format,
depending on whether the function is used in string or numeric context.
The value is expressed in the session time zone.
If the fsp argument is given to specify a fractional seconds precision
from 0 to 6, the return value includes a fractional seconds part of
that many digits.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT CURTIME();
-> '23:50:26'
mysql> SELECT CURTIME() + 0;
-> 235026.000000
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDC��@ p� � "� 6 ]DATE FUNCTION Syntax:
DATE(expr)
Extracts the date part of the date or datetime expression expr.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DATE('2003-12-31 01:02:03');
-> '2003-12-31'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD��=�@ xs � "� 6 jDATEDIFF Syntax:
DATEDIFF(expr1,expr2)
DATEDIFF() returns expr1 − expr2 expressed as a value in days from
one date to the other. expr1 and expr2 are date or date-and-time
expressions. Only the date parts of the values are used in the
calculation.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DATEDIFF('2007-12-31 23:59:59','2007-12-30');
-> 1
mysql> SELECT DATEDIFF('2010-11-30 23:59:59','2010-12-31');
-> -31
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD �
�@ �� � "� 6 wDATE_ADD Syntax:
DATE_ADD(date,INTERVAL expr unit), DATE_SUB(date,INTERVAL expr unit)
These functions perform date arithmetic. The date argument specifies
the starting date or datetime value. expr is an expression specifying
the interval value to be added or subtracted from the starting date.
expr is evaluated as a string; it may start with a - for negative
intervals. unit is a keyword indicating the units in which the
expression should be interpreted.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DATE_ADD('2018-05-01',INTERVAL 1 DAY);
-> '2018-05-02'
mysql> SELECT DATE_SUB('2018-05-01',INTERVAL 1 YEAR);
-> '2017-05-01'
mysql> SELECT DATE_ADD('2020-12-31 23:59:59',
-> INTERVAL 1 SECOND);
-> '2021-01-01 00:00:00'
mysql> SELECT DATE_ADD('2018-12-31 23:59:59',
-> INTERVAL 1 DAY);
-> '2019-01-01 23:59:59'
mysql> SELECT DATE_ADD('2100-12-31 23:59:59',
-> INTERVAL '1:1' MINUTE_SECOND);
-> '2101-01-01 00:01:00'
mysql> SELECT DATE_SUB('2025-01-01 00:00:00',
-> INTERVAL '1 1:1:1' DAY_SECOND);
-> '2024-12-30 22:58:59'
mysql> SELECT DATE_ADD('1900-01-01 00:00:00',
-> INTERVAL '-1 10' DAY_HOUR);
-> '1899-12-30 14:00:00'
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
-> '1997-12-02'
mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
-> INTERVAL '1.999999' SECOND_MICROSECOND);
-> '1993-01-01 00:00:01.000001'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDQ���@ �� � "� 6 �DATE_FORMAT Syntax:
DATE_FORMAT(date,format)
Formats the date value according to the format string.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y');
-> 'Sunday October 2009'
mysql> SELECT DATE_FORMAT('2007-10-04 22:23:00', '%H:%i:%s');
-> '22:23:00'
mysql> SELECT DATE_FORMAT('1900-10-04 22:23:00',
-> '%D %y %a %d %m %b %j');
-> '4th 00 Thu 04 10 Oct 277'
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
-> '%H %k %I %r %T %S %w');
-> '22 22 10 10:23:00 PM 22:23:00 00 6'
mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
-> '1998 52'
mysql> SELECT DATE_FORMAT('2006-06-00', '%d');
-> '00'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ �< � "� 6 �DATE_SUB Syntax:
DATE_SUB(date,INTERVAL expr unit)
See the description for DATE_ADD().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ �% � "� 6 �DAY Syntax:
DAY(date)
DAY() is a synonym for DAYOFMONTH().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD;+�@ � � "� 6 �DAYNAME Syntax:
DAYNAME(date)
Returns the name of the weekday for date. The language used for the
name is controlled by the value of the lc_time_names system variable
(https://dev.mysql.com/doc/refman/5.7/en/locale-support.html).
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYNAME('2007-02-03');
-> 'Saturday'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD5�@ �� � "� 6 �DAYOFMONTH Syntax:
DAYOFMONTH(date)
Returns the day of the month for date, in the range 1 to 31, or 0 for
dates such as '0000-00-00' or '2008-00-00' that have a zero day part.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYOFMONTH('2007-02-03');
-> 3
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD4�@ �� � "� 6 �DAYOFWEEK Syntax:
DAYOFWEEK(date)
Returns the weekday index for date (1 = Sunday, 2 = Monday, ..., 7 =
Saturday). These index values correspond to the ODBC standard.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYOFWEEK('2007-02-03');
-> 7
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD5��@ �y � "� 6 �DAYOFYEAR Syntax:
DAYOFYEAR(date)
Returns the day of the year for date, in the range 1 to 366.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYOFYEAR('2007-02-03');
-> 34
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDI���@ �s � "� 6 �EXTRACT Syntax:
EXTRACT(unit FROM date)
The EXTRACT() function uses the same kinds of unit specifiers as
DATE_ADD() or DATE_SUB(), but extracts parts from the date rather than
performing date arithmetic. For information on the unit argument, see
https://dev.mysql.com/doc/refman/5.7/en/expressions.html#temporal-inter
vals.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT EXTRACT(YEAR FROM '2019-07-02');
-> 2019
mysql> SELECT EXTRACT(YEAR_MONTH FROM '2019-07-02 01:02:03');
-> 201907
mysql> SELECT EXTRACT(DAY_MINUTE FROM '2019-07-02 01:02:03');
-> 20102
mysql> SELECT EXTRACT(MICROSECOND
-> FROM '2003-01-02 10:30:00.000123');
-> 123
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD9��@ ��> � "� 6 �FROM_DAYS Syntax:
FROM_DAYS(N)
Given a day number N, returns a DATE value.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT FROM_DAYS(730669);
-> '2000-07-03'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p,�$�U\h c�
& �?b b
(�E� 5-� 2� infimum supremumD �g�@ % � "� 6 �FROM_UNIXTIME Syntax:
FROM_UNIXTIME(unix_timestamp[,format])
Returns a representation of unix_timestamp as a datetime or character
string value. The value returned is expressed using the session time
zone. (Clients can set the session time zone as described in
https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html.)
unix_timestamp is an internal timestamp value representing seconds
since '1970-01-01 00:00:00' UTC, such as produced by the
UNIX_TIMESTAMP() function.
If format is omitted, this function returns a DATETIME value.
If unix_timestamp is an integer, the fractional seconds precision of
the DATETIME is zero. When unix_timestamp is a decimal value, the
fractional seconds precision of the DATETIME is the same as the
precision of the decimal value, up to a maximum of 6. When
unix_timestamp is a floating point number, the fractional seconds
precision of the datetime is 6.
format is used to format the result in the same way as the format
string used for the DATE_FORMAT() function. If format is supplied, the
value returned is a VARCHAR.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT FROM_UNIXTIME(1447430881);
-> '2015-11-13 10:08:01'
mysql> SELECT FROM_UNIXTIME(1447430881) + 0;
-> 20151113100801
mysql> SELECT FROM_UNIXTIME(1447430881,
-> '%Y %D %M %h:%i:%s %x');
-> '2015 13th November 10:08:01 2015'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD���@ e � "� 6
GET_FORMAT Syntax:
GET_FORMAT({DATE|TIME|DATETIME}, {'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL'})
Returns a format string. This function is useful in combination with
the DATE_FORMAT() and the STR_TO_DATE() functions.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DATE_FORMAT('2003-10-03',GET_FORMAT(DATE,'EUR'));
-> '03.10.2003'
mysql> SELECT STR_TO_DATE('10.31.2003',GET_FORMAT(DATE,'USA'));
-> '2003-10-31'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD^"�@ " � "� 6
HOUR Syntax:
HOUR(time)
Returns the hour for time. The range of the return value is 0 to 23 for
time-of-day values. However, the range of TIME values actually is much
larger, so HOUR can return values greater than 23.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT HOUR('10:05:03');
-> 10
mysql> SELECT HOUR('272:59:59');
-> 272
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD���@ (� � "� 6
LAST_DAY Syntax:
LAST_DAY(date)
Takes a date or datetime value and returns the corresponding value for
the last day of the month. Returns NULL if the argument is invalid.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT LAST_DAY('2003-02-05');
-> '2003-02-28'
mysql> SELECT LAST_DAY('2004-02-05');
-> '2004-02-29'
mysql> SELECT LAST_DAY('2004-01-01 01:01:01');
-> '2004-01-31'
mysql> SELECT LAST_DAY('2003-03-32');
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ 0D � "� 6
-LOCALTIME Syntax:
LOCALTIME, LOCALTIME([fsp])
LOCALTIME and LOCALTIME() are synonyms for NOW().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ 8Y � "� 6
:LOCALTIMESTAMP Syntax:
LOCALTIMESTAMP, LOCALTIMESTAMP([fsp])
LOCALTIMESTAMP and LOCALTIMESTAMP() are synonyms for NOW().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD�ـ@ @` � "� 6
GMAKEDATE Syntax:
MAKEDATE(year,dayofyear)
Returns a date, given year and day-of-year values. dayofyear must be
greater than 0 or the result is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MAKEDATE(2011,31), MAKEDATE(2011,32);
-> '2011-01-31', '2011-02-01'
mysql> SELECT MAKEDATE(2011,365), MAKEDATE(2014,365);
-> '2011-12-31', '2014-12-31'
mysql> SELECT MAKEDATE(2011,0);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD8�@ H� � "� 6
TMAKETIME Syntax:
MAKETIME(hour,minute,second)
Returns a time value calculated from the hour, minute, and second
arguments.
The second argument can have a fractional part.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MAKETIME(12,15,30);
-> '12:15:30'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD��Հ@ P� � "� 6
aMICROSECOND Syntax:
MICROSECOND(expr)
Returns the microseconds from the time or datetime expression expr as a
number in the range from 0 to 999999.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MICROSECOND('12:00:00.123456');
-> 123456
mysql> SELECT MICROSECOND('2019-12-31 23:59:59.000010');
-> 10
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD:��@ Xp � "� 6
nMINUTE Syntax:
MINUTE(time)
Returns the minute for time, in the range 0 to 59.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MINUTE('2008-02-03 10:05:03');
-> 5
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD0��@ `� � "� 6
{MONTH Syntax:
MONTH(date)
Returns the month for date, in the range 1 to 12 for January to
December, or 0 for dates such as '0000-00-00' or '2008-00-00' that have
a zero month part.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MONTH('2008-02-03');
-> 2
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD=0�@ h � "� 6
�MONTHNAME Syntax:
MONTHNAME(date)
Returns the full name of the month for date. The language used for the
name is controlled by the value of the lc_time_names system variable
(https://dev.mysql.com/doc/refman/5.7/en/locale-support.html).
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MONTHNAME('2008-02-03');
-> 'February'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDpׁ@ p� � "� 6
�NOW Syntax:
NOW([fsp])
Returns the current date and time as a value in 'YYYY-MM-DD hh:mm:ss'
or YYYYMMDDhhmmss format, depending on whether the function is used in
string or numeric context. The value is expressed in the session time
zone.
If the fsp argument is given to specify a fractional seconds precision
from 0 to 6, the return value includes a fractional seconds part of
that many digits.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT NOW();
-> '2007-12-15 23:50:26'
mysql> SELECT NOW() + 0;
-> 20071215235026.000000
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD6��@ x� � "� 6
�PERIOD_ADD Syntax:
PERIOD_ADD(P,N)
Adds N months to period P (in the format YYMM or YYYYMM). Returns a
value in the format YYYYMM.
*Note*:
The period argument P is not a date value.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT PERIOD_ADD(200801,2);
-> 200803
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD8�@ �� � "� 6
�PERIOD_DIFF Syntax:
PERIOD_DIFF(P1,P2)
Returns the number of months between periods P1 and P2. P1 and P2
should be in the format YYMM or YYYYMM. Note that the period arguments
P1 and P2 are not date values.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT PERIOD_DIFF(200802,200703);
-> 11
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD2��@ �u � "� 6
�QUARTER Syntax:
QUARTER(date)
Returns the quarter of the year for date, in the range 1 to 4.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT QUARTER('2008-04-01');
-> 2
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD/��@ �e � "� 6
�SECOND Syntax:
SECOND(time)
Returns the second for time, in the range 0 to 59.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT SECOND('10:05:03');
-> 3
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDlU�@ �b � "� 6
�SEC_TO_TIME Syntax:
SEC_TO_TIME(seconds)
Returns the seconds argument, converted to hours, minutes, and seconds,
as a TIME value. The range of the result is constrained to that of the
TIME data type. A warning occurs if the argument corresponds to a value
outside that range.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT SEC_TO_TIME(2378);
-> '00:39:38'
mysql> SELECT SEC_TO_TIME(2378) + 0;
-> 3938
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ �� � "� 6
�STR_TO_DATE Syntax:
STR_TO_DATE(str,format)
This is the inverse of the DATE_FORMAT() function. It takes a string
str and a format string format. STR_TO_DATE() returns a DATETIME value
if the format string contains both date and time parts, or a DATE or
TIME value if the string contains only date or time parts. If str or
format is NULL, the function returns NULL. If the date, time, or
datetime value extracted from str cannot be parsed according to the
rules followed by the server, STR_TO_DATE() returns NULL and produces a
warning.
The server scans str attempting to match format to it. The format
string can contain literal characters and format specifiers beginning
with %. Literal characters in format must match literally in str.
Format specifiers in format must match a date or time part in str. For
the specifiers that can be used in format, see the DATE_FORMAT()
function description.
mysql> SELECT STR_TO_DATE('01,5,2013','%d,%m,%Y');
-> '2013-05-01'
mysql> SELECT STR_TO_DATE('May 1, 2013','%M %d,%Y');
-> '2013-05-01'
Scanning starts at the beginning of str and fails if format is found
not to match. Extra characters at the end of str are ignored.
mysql> SELECT STR_TO_DATE('a09:30:17','a%h:%i:%s');
-> '09:30:17'
mysql> SELECT STR_TO_DATE('a09:30:17','%h:%i:%s');
-> NULL
mysql> SELECT STR_TO_DATE('09:30:17a','%h:%i:%s');
-> '09:30:17'
Unspecified date or time parts have a value of 0, so incompletely
specified values in str produce a result with some or all parts set to
0:
mysql> SELECT STR_TO_DATE('abc','abc');
-> '0000-00-00'
mysql> SELECT STR_TO_DATE('9','%m');
-> '0000-09-00'
mysql> SELECT STR_TO_DATE('9','%s');
-> '00:00:09'
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD �@ �� � "� 6
�SUBDATE Syntax:
SUBDATE(date,INTERVAL expr unit), SUBDATE(expr,days)
When invoked with the INTERVAL form of the second argument, SUBDATE()
is a synonym for DATE_SUB(). For information on the INTERVAL unit
argument, see the discussion for DATE_ADD().
mysql> SELECT DATE_SUB('2008-01-02', INTERVAL 31 DAY);
-> '2007-12-02'
mysql> SELECT SUBDATE('2008-01-02', INTERVAL 31 DAY);
-> '2007-12-02'
The second form enables the use of an integer value for days. In such
cases, it is interpreted as the number of days to be subtracted from
the date or datetime expression expr.
mysql> SELECT SUBDATE('2008-01-02 12:00:00', 31);
-> '2007-12-02 12:00:00'
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDɀ�@ �ͩ � "� 6
�SUBTIME Syntax:
SUBTIME(expr1,expr2)
SUBTIME() returns expr1 − expr2 expressed as a value in the same
format as expr1. expr1 is a time or datetime expression, and expr2 is a
time expression.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT SUBTIME('2007-12-31 23:59:59.999999','1 1:1:1.000002');
-> '2007-12-30 22:58:58.999997'
mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');
-> '-00:59:59.999999'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p"i�� / cb b (� *V�
q(E� :�� 7� infimum supremumD q�@ � "� 6
SYSDATE Syntax:
SYSDATE([fsp])
Returns the current date and time as a value in 'YYYY-MM-DD hh:mm:ss'
or YYYYMMDDhhmmss format, depending on whether the function is used in
string or numeric context.
If the fsp argument is given to specify a fractional seconds precision
from 0 to 6, the return value includes a fractional seconds part of
that many digits.
SYSDATE() returns the time at which it executes. This differs from the
behavior for NOW(), which returns a constant time that indicates the
time at which the statement began to execute. (Within a stored function
or trigger, NOW() returns the time at which the function or triggering
statement began to execute.)
mysql> SELECT NOW(), SLEEP(2), NOW();
+---------------------+----------+---------------------+
| NOW() | SLEEP(2) | NOW() |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:36 | 0 | 2006-04-12 13:47:36 |
+---------------------+----------+---------------------+
mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();
+---------------------+----------+---------------------+
| SYSDATE() | SLEEP(2) | SYSDATE() |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:44 | 0 | 2006-04-12 13:47:46 |
+---------------------+----------+---------------------+
In addition, the SET TIMESTAMP statement affects the value returned by
NOW() but not by SYSDATE(). This means that timestamp settings in the
binary log have no effect on invocations of SYSDATE().
Because SYSDATE() can return different values even within the same
statement, and is not affected by SET TIMESTAMP, it is nondeterministic
and therefore unsafe for replication if statement-based binary logging
is used. If that is a problem, you can use row-based logging.
Alternatively, you can use the --sysdate-is-now option to cause
SYSDATE() to be an alias for NOW(). This works if the option is used on
both the source and the replica.
The nondeterministic nature of SYSDATE() also means that indexes cannot
be used for evaluating expressions that refer to it.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD����@ � � "� 6 TIME FUNCTION Syntax:
TIME(expr)
Extracts the time part of the time or datetime expression expr and
returns it as a string.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TIME('2003-12-31 01:02:03');
-> '01:02:03'
mysql> SELECT TIME('2003-12-31 01:02:03.000123');
-> '01:02:03.000123'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD
���@ � � "� 6 $TIMEDIFF Syntax:
TIMEDIFF(expr1,expr2)
TIMEDIFF() returns expr1 − expr2 expressed as a time value. expr1 and
expr2 are strings which are converted to TIME or DATETIME expressions;
these must be of the same type following conversion.
The result returned by TIMEDIFF() is limited to the range allowed for
TIME values. Alternatively, you can use either of the functions
TIMESTAMPDIFF() and UNIX_TIMESTAMP(), both of which return integers.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TIMEDIFF('2000:01:01 00:00:00',
-> '2000:01:01 00:00:00.000001');
-> '-00:00:00.000001'
mysql> SELECT TIMEDIFF('2008-12-31 23:59:59.000001',
-> '2008-12-30 01:01:01.000002');
-> '46:58:57.999999'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD��p�@ (� � "� 6 1TIMESTAMP FUNCTION Syntax:
TIMESTAMP(expr), TIMESTAMP(expr1,expr2)
With a single argument, this function returns the date or datetime
expression expr as a datetime value. With two arguments, it adds the
time expression expr2 to the date or datetime expression expr1 and
returns the result as a datetime value.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TIMESTAMP('2003-12-31');
-> '2003-12-31 00:00:00'
mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');
-> '2004-01-01 00:00:00'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD�� �@ 0] � "� 6 >TIMESTAMPADD Syntax:
TIMESTAMPADD(unit,interval,datetime_expr)
Adds the integer expression interval to the date or datetime expression
datetime_expr. The unit for interval is given by the unit argument,
which should be one of the following values: MICROSECOND
(microseconds), SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, or
YEAR.
The unit value may be specified using one of keywords as shown, or with
a prefix of SQL_TSI_. For example, DAY and SQL_TSI_DAY both are legal.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
-> '2003-01-02 00:01:00'
mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');
-> '2003-01-09'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD�8�@ 8� � "� 6 KTIMESTAMPDIFF Syntax:
TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)
Returns datetime_expr2 − datetime_expr1, where datetime_expr1 and
datetime_expr2 are date or datetime expressions. One expression may be
a date and the other a datetime; a date value is treated as a datetime
having the time part '00:00:00' where necessary. The unit for the
result (an integer) is given by the unit argument. The legal values for
unit are the same as those listed in the description of the
TIMESTAMPADD() function.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
-> 3
mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
-> -1
mysql> SELECT TIMESTAMPDIFF(MINUTE,'2003-02-01','2003-05-01 12:05:55');
-> 128885
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDW0�@ @( � "� 6 XTIME_FORMAT Syntax:
TIME_FORMAT(time,format)
This is used like the DATE_FORMAT() function, but the format string may
contain format specifiers only for hours, minutes, seconds, and
microseconds. Other specifiers produce a NULL value or 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
-> '100 100 04 04 4'
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDo��@ H� � "� 6 eTIME_TO_SEC Syntax:
TIME_TO_SEC(time)
Returns the time argument, converted to seconds.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TIME_TO_SEC('22:23:00');
-> 80580
mysql> SELECT TIME_TO_SEC('00:39:38');
-> 2378
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDh��@ P� � "� 6 rTO_DAYS Syntax:
TO_DAYS(date)
Given a date date, returns a day number (the number of days since year
0).
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TO_DAYS(950501);
-> 728779
mysql> SELECT TO_DAYS('2007-10-07');
-> 733321
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD���@ X� � "� 6 TO_SECONDS Syntax:
TO_SECONDS(expr)
Given a date or datetime expr, returns the number of seconds since the
year 0. If expr is not a valid date or datetime value, returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT TO_SECONDS(950501);
-> 62966505600
mysql> SELECT TO_SECONDS('2009-11-29');
-> 63426672000
mysql> SELECT TO_SECONDS('2009-11-29 13:43:32');
-> 63426721412
mysql> SELECT TO_SECONDS( NOW() );
-> 63426721458
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDԀ��@ ` � "� 6 �UNIX_TIMESTAMP Syntax:
UNIX_TIMESTAMP([date])
If UNIX_TIMESTAMP() is called with no date argument, it returns a Unix
timestamp representing seconds since '1970-01-01 00:00:00' UTC.
If UNIX_TIMESTAMP() is called with a date argument, it returns the
value of the argument as seconds since '1970-01-01 00:00:00' UTC. The
server interprets date as a value in the session time zone and converts
it to an internal Unix timestamp value in UTC. (Clients can set the
session time zone as described in
https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html.) The
date argument may be a DATE, DATETIME, or TIMESTAMP string, or a number
in YYMMDD, YYMMDDhhmmss, YYYYMMDD, or YYYYMMDDhhmmss format. If the
argument includes a time part, it may optionally include a fractional
seconds part.
The return value is an integer if no argument is given or the argument
does not include a fractional seconds part, or DECIMAL if an argument
is given that includes a fractional seconds part.
When the date argument is a TIMESTAMP column, UNIX_TIMESTAMP() returns
the internal timestamp value directly, with no implicit
"string-to-Unix-timestamp" conversion.
The valid range of argument values is the same as for the TIMESTAMP
data type: '1970-01-01 00:00:01.000000' UTC to '2038-01-19
03:14:07.999999' UTC. If you pass an out-of-range date to
UNIX_TIMESTAMP(), it returns 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT UNIX_TIMESTAMP();
-> 1447431666
mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19');
-> 1447431619
mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19.012');
-> 1447431619.012
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDL��@ h� � "� 6 �UTC_DATE Syntax:
UTC_DATE, UTC_DATE()
Returns the current UTC date as a value in 'YYYY-MM-DD' or YYYYMMDD
format, depending on whether the function is used in string or numeric
context.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
-> '2003-08-14', 20030814
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDO��@ p� � "� 6 �UTC_TIME Syntax:
UTC_TIME, UTC_TIME([fsp])
Returns the current UTC time as a value in 'hh:mm:ss' or hhmmss format,
depending on whether the function is used in string or numeric context.
If the fsp argument is given to specify a fractional seconds precision
from 0 to 6, the return value includes a fractional seconds part of
that many digits.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
-> '18:07:53', 180753.000000
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDlÁ@ x� � "� 6 �UTC_TIMESTAMP Syntax:
UTC_TIMESTAMP, UTC_TIMESTAMP([fsp])
Returns the current UTC date and time as a value in 'YYYY-MM-DD
hh:mm:ss' or YYYYMMDDhhmmss format, depending on whether the function
is used in string or numeric context.
If the fsp argument is given to specify a fractional seconds precision
from 0 to 6, the return value includes a fractional seconds part of
that many digits.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
-> '2003-08-14 18:08:04', 20030814180804.000000
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDÀ��@ �Y � "� 6 �WEEK Syntax:
WEEK(date[,mode])
This function returns the week number for date. The two-argument form
of WEEK() enables you to specify whether the week starts on Sunday or
Monday and whether the return value should be in the range from 0 to 53
or from 1 to 53. If the mode argument is omitted, the value of the
default_week_format system variable is used. See
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT WEEK('2008-02-20');
-> 7
mysql> SELECT WEEK('2008-02-20',0);
-> 7
mysql> SELECT WEEK('2008-02-20',1);
-> 8
mysql> SELECT WEEK('2008-12-31',1);
-> 53
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDm��@ �� � "� 6 �WEEKDAY Syntax:
WEEKDAY(date)
Returns the weekday index for date (0 = Monday, 1 = Tuesday, ... 6 =
Sunday).
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT WEEKDAY('2008-02-03 22:23:00');
-> 6
mysql> SELECT WEEKDAY('2007-11-06');
-> 1
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD5 �@ �� � "� 6 �WEEKOFYEAR Syntax:
WEEKOFYEAR(date)
Returns the calendar week of the date as a number in the range from 1
to 53. WEEKOFYEAR() is a compatibility function that is equivalent to
WEEK(date,3).
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT WEEKOFYEAR('2008-02-20');
-> 8
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD2��@ �� � "� 6 �YEAR Syntax:
YEAR(date)
Returns the year for date, in the range 1000 to 9999, or 0 for the
"zero" date.
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT YEAR('1987-01-01');
-> 1987
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD8�@ �ȕ � "� 6 �YEARWEEK Syntax:
YEARWEEK(date), YEARWEEK(date,mode)
Returns year and week for a date. The year in the result may be
different from the year in the date argument for the first and the last
week of the year.
The mode argument works exactly like the mode argument to WEEK(). For
the single-argument syntax, a mode value of 0 is used. Unlike WEEK(),
the value of default_week_format does not influence YEARWEEK().
URL: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT YEARWEEK('1987-01-01');
-> 198652
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p(!-) c *V� q(5�2�
�E� ;� 7' infimum supremum=x�@ � "� 6 ASCII Syntax:
ASCII(str)
Returns the numeric value of the leftmost character of the string str.
Returns 0 if str is the empty string. Returns NULL if str is NULL.
ASCII() works for 8-bit characters.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT ASCII('2');
-> 50
mysql> SELECT ASCII(2);
-> 50
mysql> SELECT ASCII('dx');
-> 100
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=)��@ � � "� 6 BIN Syntax:
BIN(N)
Returns a string representation of the binary value of N, where N is a
longlong (BIGINT) number. This is equivalent to CONV(N,10,2). Returns
NULL if N is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT BIN(12);
-> '1100'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=0��@ V � "� 6 BIT_LENGTH Syntax:
BIT_LENGTH(str)
Returns the length of the string str in bits.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT BIT_LENGTH('text');
-> 32
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=o��@ (� � "� 6 (CHAR FUNCTION Syntax:
CHAR(N,... [USING charset_name])
CHAR() interprets each argument N as an integer and returns a string
consisting of the characters given by the code values of those
integers. NULL values are skipped.
By default, CHAR() returns a binary string. To produce a string in a
given character set, use the optional USING clause:
mysql> SELECT CHARSET(CHAR(X'65')), CHARSET(CHAR(X'65' USING utf8));
+----------------------+---------------------------------+
| CHARSET(CHAR(X'65')) | CHARSET(CHAR(X'65' USING utf8)) |
+----------------------+---------------------------------+
| binary | utf8 |
+----------------------+---------------------------------+
If USING is given and the result string is illegal for the given
character set, a warning is issued. Also, if strict SQL mode is
enabled, the result from CHAR() becomes NULL.
If CHAR() is invoked from within the mysql client, binary strings
display using hexadecimal notation, depending on the value of the
--binary-as-hex. For more information about that option, see
https://dev.mysql.com/doc/refman/5.7/en/mysql.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT CHAR(77,121,83,81,'76');
-> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
-> 'MMM'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= ͂@ 0g � "� 6 5CHAR_LENGTH Syntax:
CHAR_LENGTH(str)
Returns the length of the string str, measured in code points. A
multibyte character counts as a single code point. This means that, for
a string containing two 3-byte characters, LENGTH() returns 6, whereas
CHAR_LENGTH() returns 2, as shown here:
mysql> SET @dolphin:='海豚';
Query OK, 0 rows affected (0.01 sec)
mysql> SELECT LENGTH(@dolphin), CHAR_LENGTH(@dolphin);
+------------------+-----------------------+
| LENGTH(@dolphin) | CHAR_LENGTH(@dolphin) |
+------------------+-----------------------+
| 6 | 2 |
+------------------+-----------------------+
1 row in set (0.00 sec)
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= ��@ 82 � "� 6 BCHARACTER_LENGTH Syntax:
CHARACTER_LENGTH(str)
CHARACTER_LENGTH() is a synonym for CHAR_LENGTH().
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=��Ձ@ @ � "� 6 OCONCAT Syntax:
CONCAT(str1,str2,...)
Returns the string that results from concatenating the arguments. May
have one or more arguments. If all arguments are nonbinary strings, the
result is a nonbinary string. If the arguments include any binary
strings, the result is a binary string. A numeric argument is converted
to its equivalent nonbinary string form.
CONCAT() returns NULL if any argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT CONCAT('My', 'S', 'QL');
-> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
-> NULL
mysql> SELECT CONCAT(14.3);
-> '14.3'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=р��@ H" � "� 6 \CONCAT_WS Syntax:
CONCAT_WS(separator,str1,str2,...)
CONCAT_WS() stands for Concatenate With Separator and is a special form
of CONCAT(). The first argument is the separator for the rest of the
arguments. The separator is added between the strings to be
concatenated. The separator can be a string, as can the rest of the
arguments. If the separator is NULL, the result is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT CONCAT_WS(',','First name','Second name','Last Name');
-> 'First name,Second name,Last Name'
mysql> SELECT CONCAT_WS(',','First name',NULL,'Last Name');
-> 'First name,Last Name'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=|5�@ PL � "� 6 iELT Syntax:
ELT(N,str1,str2,str3,...)
ELT() returns the Nth element of the list of strings: str1 if N = 1,
str2 if N = 2, and so on. Returns NULL if N is less than 1 or greater
than the number of arguments. ELT() is the complement of FIELD().
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');
-> 'Aa'
mysql> SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');
-> 'Dd'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=���@ X
� "� 6 vEXPORT_SET Syntax:
EXPORT_SET(bits,on,off[,separator[,number_of_bits]])
Returns a string such that for every bit set in the value bits, you get
an on string and for every bit not set in the value, you get an off
string. Bits in bits are examined from right to left (from low-order to
high-order bits). Strings are added to the result from left to right,
separated by the separator string (the default being the comma
character ,). The number of bits examined is given by number_of_bits,
which has a default of 64 if not specified. number_of_bits is silently
clipped to 64 if larger than 64. It is treated as an unsigned integer,
so a value of −1 is effectively the same as 64.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT EXPORT_SET(5,'Y','N',',',4);
-> 'Y,N,Y,N'
mysql> SELECT EXPORT_SET(6,'1','0',',',10);
-> '0,1,1,0,0,0,0,0,0,0'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=���@ `8 � "� 6 �FIELD Syntax:
FIELD(str,str1,str2,str3,...)
Returns the index (position) of str in the str1, str2, str3, ... list.
Returns 0 if str is not found.
If all arguments to FIELD() are strings, all arguments are compared as
strings. If all arguments are numbers, they are compared as numbers.
Otherwise, the arguments are compared as double.
If str is NULL, the return value is 0 because NULL fails equality
comparison with any value. FIELD() is the complement of ELT().
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
-> 2
mysql> SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
-> 0
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=7��@ hT � "� 6 �FIND_IN_SET Syntax:
FIND_IN_SET(str,strlist)
Returns a value in the range of 1 to N if the string str is in the
string list strlist consisting of N substrings. A string list is a
string composed of substrings separated by , characters. If the first
argument is a constant string and the second is a column of type SET,
the FIND_IN_SET() function is optimized to use bit arithmetic. Returns
0 if str is not in strlist or if strlist is the empty string. Returns
NULL if either argument is NULL. This function does not work properly
if the first argument contains a comma (,) character.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
-> 2
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=�@ p � "� 6 �FORMAT Syntax:
FORMAT(X,D[,locale])
Formats the number X to a format like '#,###,###.##', rounded to D
decimal places, and returns the result as a string. If D is 0, the
result has no decimal point or fractional part.
The optional third parameter enables a locale to be specified to be
used for the result number's decimal point, thousands separator, and
grouping between separators. Permissible locale values are the same as
the legal values for the lc_time_names system variable (see
https://dev.mysql.com/doc/refman/5.7/en/locale-support.html). If no
locale is specified, the default is 'en_US'.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT FORMAT(12332.123456, 4);
-> '12,332.1235'
mysql> SELECT FORMAT(12332.1,4);
-> '12,332.1000'
mysql> SELECT FORMAT(12332.2,0);
-> '12,332'
mysql> SELECT FORMAT(12332.2,2,'de_DE');
-> '12.332,20'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=X|�@ xo � "� 6 �FROM_BASE64 Syntax:
FROM_BASE64(str)
Takes a string encoded with the base-64 encoded rules used by
TO_BASE64() and returns the decoded result as a binary string. The
result is NULL if the argument is NULL or not a valid base-64 string.
See the description of TO_BASE64() for details about the encoding and
decoding rules.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
-> 'JWJj', 'abc'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=��s�@ �� � "� 6 �HEX Syntax:
HEX(str), HEX(N)
For a string argument str, HEX() returns a hexadecimal string
representation of str where each byte of each character in str is
converted to two hexadecimal digits. (Multibyte characters therefore
become more than two digits.) The inverse of this operation is
performed by the UNHEX() function.
For a numeric argument N, HEX() returns a hexadecimal string
representation of the value of N treated as a longlong (BIGINT) number.
This is equivalent to CONV(N,10,16). The inverse of this operation is
performed by CONV(HEX(N),16,10).
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT X'616263', HEX('abc'), UNHEX(HEX('abc'));
-> 'abc', 616263, 'abc'
mysql> SELECT HEX(255), CONV(HEX(255),16,10);
-> 'FF', 255
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=Á@ �5 � "� 6 �INSERT FUNCTION Syntax:
INSERT(str,pos,len,newstr)
Returns the string str, with the substring beginning at position pos
and len characters long replaced by the string newstr. Returns the
original string if pos is not within the length of the string. Replaces
the rest of the string from position pos if len is not within the
length of the rest of the string. Returns NULL if any argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
-> 'QuWhattic'
mysql> SELECT INSERT('Quadratic', -1, 4, 'What');
-> 'Quadratic'
mysql> SELECT INSERT('Quadratic', 3, 100, 'What');
-> 'QuWhat'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=j�@ � � "� 6 �INSTR Syntax:
INSTR(str,substr)
Returns the position of the first occurrence of substring substr in
string str. This is the same as the two-argument form of LOCATE(),
except that the order of the arguments is reversed.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT INSTR('foobarbar', 'bar');
-> 4
mysql> SELECT INSTR('xbar', 'foobar');
-> 0
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= {@ � � "� 6 �LCASE Syntax:
LCASE(str)
LCASE() is a synonym for LOWER().
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=7��@ �� � "� 6 �LEFT Syntax:
LEFT(str,len)
Returns the leftmost len characters from the string str, or NULL if any
argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LEFT('foobarbar', 5);
-> 'fooba'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=+9�@ �� � "� 6 �LENGTH Syntax:
LENGTH(str)
Returns the length of the string str, measured in bytes. A multibyte
character counts as multiple bytes. This means that for a string
containing five 2-byte characters, LENGTH() returns 10, whereas
CHAR_LENGTH() returns 5.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LENGTH('text');
-> 4
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=[ �@ ��I � "� 6
LOAD_FILE Syntax:
LOAD_FILE(file_name)
Reads the file and returns the file contents as a string. To use this
function, the file must be located on the server host, you must specify
the full path name to the file, and you must have the FILE privilege.
The file must be readable by all and its size less than
max_allowed_packet bytes. If the secure_file_priv system variable is
set to a nonempty directory name, the file to be loaded must be located
in that directory.
If the file does not exist or cannot be read because one of the
preceding conditions is not satisfied, the function returns NULL.
The character_set_filesystem system variable controls interpretation of
file names that are given as literal strings.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> UPDATE t
SET blob_col=LOAD_FILE('/tmp/picture')
WHERE id=1;
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html p-: ��� c5�2� ���r ^�E� ;�� 8� infimum supremum=����@ � � "� 6
LOCATE Syntax:
LOCATE(substr,str), LOCATE(substr,str,pos)
The first syntax returns the position of the first occurrence of
substring substr in string str. The second syntax returns the position
of the first occurrence of substring substr in string str, starting at
position pos. Returns 0 if substr is not in str. Returns NULL if substr
or str is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LOCATE('bar', 'foobarbar');
-> 4
mysql> SELECT LOCATE('xbar', 'foobar');
-> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
-> 7
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= 0�@ � � "� 6
LOWER Syntax:
LOWER(str)
Returns the string str with all characters changed to lowercase
according to the current character set mapping. The default is latin1
(cp1252 West European).
mysql> SELECT LOWER('QUADRATICALLY');
-> 'quadratically'
LOWER() (and UPPER()) are ineffective when applied to binary strings
(BINARY, VARBINARY, BLOB). To perform lettercase conversion of a binary
string, first convert it to a nonbinary string using a character set
appropriate for the data stored in the string:
mysql> SET @str = BINARY 'New York';
mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING latin1));
+-------------+-----------------------------------+
| LOWER(@str) | LOWER(CONVERT(@str USING latin1)) |
+-------------+-----------------------------------+
| New York | new york |
+-------------+-----------------------------------+
For collations of Unicode character sets, LOWER() and UPPER() work
according to the Unicode Collation Algorithm (UCA) version in the
collation name, if there is one, and UCA 4.0.0 if no version is
specified. For example, utf8_unicode_520_ci works according to UCA
5.2.0, whereas utf8_unicode_ci works according to UCA 4.0.0. See
https://dev.mysql.com/doc/refman/5.7/en/charset-unicode-sets.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=c �@ � "� 6
,LPAD Syntax:
LPAD(str,len,padstr)
Returns the string str, left-padded with the string padstr to a length
of len characters. If str is longer than len, the return value is
shortened to len characters.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LPAD('hi',4,'??');
-> '??hi'
mysql> SELECT LPAD('hi',1,'??');
-> 'h'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=5��@ (g � "� 6
9LTRIM Syntax:
LTRIM(str)
Returns the string str with leading space characters removed.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LTRIM(' barbar');
-> 'barbar'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=�u�@ 0 � "� 6
FMAKE_SET Syntax:
MAKE_SET(bits,str1,str2,...)
Returns a set value (a string containing substrings separated by ,
characters) consisting of the strings that have the corresponding bit
in bits set. str1 corresponds to bit 0, str2 to bit 1, and so on. NULL
values in str1, str2, ... are not appended to the result.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT MAKE_SET(1,'a','b','c');
-> 'a'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
-> 'hello,world'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');
-> 'hello'
mysql> SELECT MAKE_SET(0,'a','b','c');
-> ''
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= ��@ 83 � "� 6
SMID Syntax:
MID(str,pos,len)
MID(str,pos,len) is a synonym for SUBSTRING(str,pos,len).
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html='�@ @� � "� 6
`OCT Syntax:
OCT(N)
Returns a string representation of the octal value of N, where N is a
longlong (BIGINT) number. This is equivalent to CONV(N,10,8). Returns
NULL if N is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT OCT(12);
-> '14'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= ��@ H$ � "� 6
mOCTET_LENGTH Syntax:
OCTET_LENGTH(str)
OCTET_LENGTH() is a synonym for LENGTH().
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=&ʁ@ P� � "� 6
zORD Syntax:
ORD(str)
If the leftmost character of the string str is a multibyte character,
returns the code for that character, calculated from the numeric values
of its constituent bytes using this formula:
(1st byte code)
+ (2nd byte code * 256)
+ (3rd byte code * 256^2) ...
If the leftmost character is not a multibyte character, ORD() returns
the same value as the ASCII() function.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT ORD('2');
-> 50
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= ��@ X= � "� 6
�POSITION Syntax:
POSITION(substr IN str)
POSITION(substr IN str) is a synonym for LOCATE(substr,str).
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=`ҁ@ `� � "� 6
�QUOTE Syntax:
QUOTE(str)
Quotes a string to produce a result that can be used as a properly
escaped data value in an SQL statement. The string is returned enclosed
by single quotation marks and with each instance of backslash (\),
single quote ('), ASCII NUL, and Control+Z preceded by a backslash. If
the argument is NULL, the return value is the word "NULL" without
enclosing single quotation marks.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT QUOTE('Don\'t!');
-> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=?��@ h� � "� 6
�REPEAT FUNCTION Syntax:
REPEAT(str,count)
Returns a string consisting of the string str repeated count times. If
count is less than 1, returns an empty string. Returns NULL if str or
count are NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT REPEAT('MySQL', 3);
-> 'MySQLMySQLMySQL'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=Q�@ p� � "� 6
�REPLACE FUNCTION Syntax:
REPLACE(str,from_str,to_str)
Returns the string str with all occurrences of the string from_str
replaced by the string to_str. REPLACE() performs a case-sensitive
match when searching for from_str.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
-> 'WwWwWw.mysql.com'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=/��@ xf � "� 6
�REVERSE Syntax:
REVERSE(str)
Returns the string str with the order of the characters reversed.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT REVERSE('abc');
-> 'cba'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=7��@ �� � "� 6
�RIGHT Syntax:
RIGHT(str,len)
Returns the rightmost len characters from the string str, or NULL if
any argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT RIGHT('foobarbar', 4);
-> 'rbar'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=b
�@ � � "� 6
�RPAD Syntax:
RPAD(str,len,padstr)
Returns the string str, right-padded with the string padstr to a length
of len characters. If str is longer than len, the return value is
shortened to len characters.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT RPAD('hi',5,'?');
-> 'hi???'
mysql> SELECT RPAD('hi',1,'?');
-> 'h'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=6��@ �h � "� 6
�RTRIM Syntax:
RTRIM(str)
Returns the string str with trailing space characters removed.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT RTRIM('barbar ');
-> 'barbar'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=nȃ@ �� � "� 6
�SOUNDEX Syntax:
SOUNDEX(str)
Returns a soundex string from str. Two strings that sound almost the
same should have identical soundex strings. A standard soundex string
is four characters long, but the SOUNDEX() function returns an
arbitrarily long string. You can use SUBSTRING() on the result to get a
standard soundex string. All nonalphabetic characters in str are
ignored. All international alphabetic characters outside the A-Z range
are treated as vowels.
*Important*:
When using SOUNDEX(), you should be aware of the following limitations:
o This function, as currently implemented, is intended to work well
with strings that are in the English language only. Strings in other
languages may not produce reliable results.
o This function is not guaranteed to provide consistent results with
strings that use multibyte character sets, including utf-8. See Bug
#22638 for more information.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT SOUNDEX('Hello');
-> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
-> 'Q36324'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= ��@ �5 � "� 6
�SOUNDS LIKE Syntax:
expr1 SOUNDS LIKE expr2
This is the same as SOUNDEX(expr1) = SOUNDEX(expr2).
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=,��@ �P � "� 6 SPACE Syntax:
SPACE(N)
Returns a string consisting of N space characters.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT SPACE(6);
-> ' '
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= @ �i � "� 6SUBSTR Syntax:
SUBSTR(str,pos), SUBSTR(str FROM pos), SUBSTR(str,pos,len), SUBSTR(str
FROM pos FOR len)
SUBSTR() is a synonym for SUBSTRING().
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=z�e�@ �z � "� 6#SUBSTRING Syntax:
SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len),
SUBSTRING(str FROM pos FOR len)
The forms without a len argument return a substring from string str
starting at position pos. The forms with a len argument return a
substring len characters long from string str, starting at position
pos. The forms that use FROM are standard SQL syntax. It is also
possible to use a negative value for pos. In this case, the beginning
of the substring is pos characters from the end of the string, rather
than the beginning. A negative value may be used for pos in any of the
forms of this function. A value of 0 for pos returns an empty string.
For all forms of SUBSTRING(), the position of the first character in
the string from which the substring is to be extracted is reckoned as
1.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT SUBSTRING('Quadratically',5);
-> 'ratically'
mysql> SELECT SUBSTRING('foobarbar' FROM 4);
-> 'barbar'
mysql> SELECT SUBSTRING('Quadratically',5,6);
-> 'ratica'
mysql> SELECT SUBSTRING('Sakila', -3);
-> 'ila'
mysql> SELECT SUBSTRING('Sakila', -5, 3);
-> 'aki'
mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);
-> 'ki'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=���@ �! � "� 60SUBSTRING_INDEX Syntax:
SUBSTRING_INDEX(str,delim,count)
Returns the substring from string str before count occurrences of the
delimiter delim. If count is positive, everything to the left of the
final delimiter (counting from the left) is returned. If count is
negative, everything to the right of the final delimiter (counting from
the right) is returned. SUBSTRING_INDEX() performs a case-sensitive
match when searching for delim.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
-> 'www.mysql'
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
-> 'mysql.com'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=X��@ �� � "� 6=TO_BASE64 Syntax:
TO_BASE64(str)
Converts the string argument to base-64 encoded form and returns the
result as a character string with the connection character set and
collation. If the argument is not a string, it is converted to a string
before conversion takes place. The result is NULL if the argument is
NULL. Base-64 encoded strings can be decoded using the FROM_BASE64()
function.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
-> 'JWJj', 'abc'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=��p�@ ��� � "� 6JTRIM Syntax:
TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM([remstr
FROM] str)
Returns the string str with all remstr prefixes or suffixes removed. If
none of the specifiers BOTH, LEADING, or TRAILING is given, BOTH is
assumed. remstr is optional and, if not specified, spaces are removed.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT TRIM(' bar ');
-> 'bar'
mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
-> 'barxxx'
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
-> 'bar'
mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
-> 'barx'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html p*�!P� 3 c��r ^��F)C ���� ( #�.E� ?|��&\ T� x " infimum supremum@ J! L@ J!= :@ % \@ ( J* Y@ 0 J+ V@ 8 J- BINARY W@ @+�- UNARY X@ H J/ Z@ P �< <@ X J<= ;@ ` J<=> 9@ h J= 8@ p J> >@ x |>= =@ � JABS ]@ � JACOS ^@ � JADDDATE {@ � �ADDTIME |@ �+\AND M@ � JASCII �@ � JASIN _@ � JASSIGN-EQUAL Q@ �" ASSIGN-VALUE P@ � JASYMMETRIC_DECRYPT @ � JASYMMETRIC_DERIVE @ � JASYMMETRIC_ENCRYPT @ � JASYMMETRIC_SIGN @ � JASYMMETRIC_VERIFY @ � JATAN `@ � JATAN2 a@ %�AUTO_INCREMENT @ JBETWEEN AND ?@ JBIGINT @ JBIN �@ �BINARY &@($�BIT @ 0$�BIT_LENGTH �@ 8 JBLOB *@ @ JBLOB DATA TYPE 2@H BOOLEAN @ P�CASE OPERATOR R@ X JCEIL b@ ` ZCEILING c@h JCHAR #@ p JCHAR BYTE $@ x JCHAR FUNCTION �@ �jCHARACTER_LENGTH �@� ZCHAR_LENGTH �@ � COALESCE A@ � JCONCAT �@ � CONCAT_WS �@�XCONV d@ � �CONVERT_TZ }@ � JCOS e@ � COT f@�%�CRC32 g@ ��CASE STATEMENT 5@ �fCLOSE =@ �$lALTER USER F@ ��&ANALYZE TABLE M@ �"CHECKSUM TABLE O@ �$�CREATE FUNCTION LOADABLE FUNCTION R@ �2BINLOG �@ *4CACHE INDEX �@ �CURTIME �@ JDATE @ JDATE FUNCTION �@( JDATEDIFF �@ 0 JDATETIME @ 8 JDATE_ADD �@ @ JDATE_FORMAT �@H JDATE_SUB �@ P JDAY �@ X JDAYNAME �@ ` JDAYOFMONTH �@h JDAYOFWEEK �@ p JDAYOFYEAR �@ x JDEC @ � $DECIMAL @�%�DEGREES h@ �%�DIV [@ � JDOUBLE @�!�DOUBLE PRECISION @� �ELT �@��ENUM 0@ � JEXP i@ ��EXPORT_SET �@�:EXTRACT �@ � JFALSE @ � JFIELD �@ � JFIND_IN_SET �@� JFLOAT @ � JFLOOR j@ � 2FLUSH QUERY CACHE @ FFORMAT �@ JFROM_BASE64 �@ JFROM_DAYS �@
�FROM_UNIXTIME �@ �GEOMETRY HIERARCHY 3@(�GET_FORMAT �@ 0^GREATEST B@ 8 JHELP COMMAND @ @ JHELP_DATE @H JHELP_VERSION @ P JHEX �@ X JHOUR �@ ` JIF FUNCTION S@h JIFNULL T@ p�IN C@ x�jBINARY OPERATOR �@��CAST �@ ���CONVERT �@ ��EXTRACTVALUE �@ ��4& �@ ��<< �@ ���>> �@ ���BIT_COUNT �@ � JAES_DECRYPT �@�0AES_ENCRYPT �@���COMPRESS �@ �*DECODE �@ � JDES_DECRYPT �@ �~DES_ENCRYPT @ � JENCODE @ ��ENCRYPT @ ��GET_LOCK @ �BENCHMARK @ ��CHARSET @ JCOERCIBILITY @ �COLLATION @ �CONNECTION_ID @ (�CURRENT_USER @ 0�DATABASE @ 8�FOUND_ROWS @ @ �GEOMCOLLFROMTEXT @ H �GEOMFROMTEXT @P�GEOMCOLLFROMWKB /@ X�GEOMFROMWKB 0@ `.GEOMETRYCOLLECTION ?@ h�PASBINARY F@ p�.ASTEXT G@ x DIMENSION J@ � ENVELOPE K@ ���GEOMETRYTYPE L@ ��ENDPOINT Z@ ��GLENGTH [@ ���AREA f@ �
�CENTROID g@ ��^EXTERIORRING h@ ��DGEOMETRYN p@ ���BUFFER t@ ��CONVEXHULL u@ ��hCHECK TABLE N@ ���DISTANCE ~@ ��:CONTAINS �@�lDISJOINT �@ ��zEQUALS �@ � J-> �@ �Z->> �@ JGTID_SUBSET �@ ��GTID_SUBTRACT �@ �AVG �@ �BIT_AND �@ ( JBIT_OR �@ 0�JBIT_XOR �@ 8 JCOUNT �@ @��COUNT DISTINCT �@H��GROUP_CONCAT �@ P��ANY_VALUE �@ X�DEFAULT �@ ` JINET_ATON �@ h �INET_NTOA �@ p JINET6_ATON �@ x�"INET6_NTOA �@ � �ALTER DATABASE �@��ALTER SCHEMA �@ � JALTER EVENT �@ � JALTER FUNCTION �@ � JALTER INSTANCE �@ � JALTER LOGFILE GROUP �@ ���ALTER PROCEDURE �@ � JALTER SERVER �@ � JALTER TABLE �@ ���ALTER TABLESPACE �@���ALTER VIEW �@ � �CREATE DATABASE �@ ��.CREATE SCHEMA �@ �(CREATE EVENT �@ � JCREATE INDEX �@� JCREATE LOGFILE GROUP �@ ��CREATE PROCEDURE �@ �lCREATE FUNCTION �@ rBEGIN @ �COMMIT @ �FOREIGN KEY �@ ( JCHANGE MASTER TO (@ 0��CHANGE REPLICATION FILTER )@ 8�zBEGIN END 2@ @ �DROP DATABASE �@ HrDROP SCHEMA �@ P �DROP EVENT @X JDROP INDEX @ `�"DROP PROCEDURE @ h�lDROP FUNCTION @ p JDROP SERVER @ x JDROP TABLE @ � JDROP TABLESPACE @ � JDROP TRIGGER @ ���DROP VIEW @ ��&CALL @ ��FDELETE @ ��lDO
@ � JWEEKOFYEAR �@ � JWKT DEFINITION 5@ � JXOR O@ � JYEAR �@ � JYEAR DATA TYPE "@ � YEARWEEK � p=|<T;,:8�7�6�5d4<31�0�/� p l D0� '�����|:�2-LT,�� p7 d<"� � J �
� tL$�5�3"����\ c�F)C #�.��^V ( $�E� %?|��(��(� � " infimum supremum@ 8�INSERT FUNCTION �@ JINSTR �@ JINT @ (<jINTEGER @ 0 JINTERVAL E@ 8 JIS F@ @ JIS NOT G@ H JIS NOT NULL I@ P8IS NULL H@ X4RISNULL J@ `'PLAST_DAY �@ h JLCASE �@ p�LEAST K@ x JLEFT �@ � �LENGTH �@ �8^LN k@ � JLOAD_FILE �@ � JLOCALTIME �@ � JLOCALTIMESTAMP �@ �%�LOCATE �@ � JLOG l@ � JLOG10 n@ � JLOG2 m@ � JLONGBLOB .@ ��LONGTEXT /@ � JLOWER �@ � JLPAD �@ � JLTRIM �@ � JMAKEDATE �@ � JMAKETIME �@ 3�MAKE_SET �@
MBR DEFINITION 4@ JMEDIUMBLOB ,@ JMEDIUMINT @ ZMEDIUMTEXT -@( JMICROSECOND �@ 0% MID �@ 8!�MINUTE �@ @ JMOD o@H JMONTH �@ P!>MONTHNAME �@ X JNOT BETWEEN @@ `�NOT IN D@h JNOW �@ p ZNULLIF U@ x JOCT �@ � $OCTET_LENGTH �@� JOR N@ ��ORD �@ � JPERIOD_ADD �@ � JPERIOD_DIFF �@�&�PI p@ � JPOSITION �@ � JPOW q@ ��POWER r@�\PROCEDURE ANALYSE
@ � JQUARTER �@ � JQUOTE �@ � JRADIANS s@�BRAND t@ ��REPEAT FUNCTION �@�REPLACE FUNCTION �@ 0REVERSE �@HROUND u@ JSECOND �@ �SEC_TO_TIME �@ �MBRCONTAINS �@( JMBRDISJOINT �@ 0 JMBREQUAL �@ 8 nMBREQUALS �@ @�MBRWITHIN �@ H�INTERSECTS �@ P6OVERLAPS �@X(�JSON_CONTAINS �@ `�SELECT @ h��ROLLBACK TO SAVEPOINT @ p�RELEASE SAVEPOINT @ x JPURGE BINARY LOGS $@ ���PURGE MASTER LOGS %@ � JRESET MASTER &@ ��RESET SLAVE *@ ��|PREPARE .@ ��0LABELS 3@ � @ITERATE 7@ ��zLEAVE 8@ ��LOOP 9@ � �REPEAT LOOP :@��RETURN ;@ � �OPEN @@ �lRESIGNAL D@ � �RENAME USER J@ ��HOPTIMIZE TABLE P@ �REPAIR TABLE Q@ ���KILL �@ LOAD INDEX �@
UNIX_TIMESTAMP �@ JUTC_DATE �@ JUTC_TIME �@ nUTC_TIMESTAMP �@( JVARBINARY '@ 0VARCHAR %@ 8 JWEEK �@ @ JWEEKDAY �@H�WEEKOFYEAR �@ P�WKT DEFINITION 5@ X�XOR O@` JYEAR �@ h JYEAR DATA TYPE "@ p�YEARWEEK �@ xRIGHT �@ � JRPAD �@ ��RTRIM �@ � JMBRINTERSECTS �@� JMBROVERLAPS �@ ��HMBRTOUCHES �@ �BJOIN @ ��&ROLLBACK @ ��SAVEPOINT @ ��fREVOKE K@ ���INSTALL PLUGIN T@ ��&RESET �@ �|UNHEX �@ �bUPPER �@ �WEIGHT_STRING �@ �bLIKE �@ � �NOT LIKE �@ �JSON_QUOTE �@ �NOT REGEXP �@ �REGEXP �@
�MATCH AGAINST �@ ��UPDATEXML �@ ( �| �@ 0��^ �@ 8 ~ �@ @�MD5 @ H�$PASSWORD @ P��RANDOM_BYTES @ X JMBRCOVEREDBY �@ `�zMBRCOVERS �@ h��MERGE �@ p��UNCOMPRESSED_LENGTH @ x��VALIDATE_PASSWORD_STRENGTH
@ �
hIS_FREE_LOCK @ ��IS_USED_LOCK
@ � JRELEASE_ALL_LOCKS @�
RELEASE_LOCK @ ��LAST_INSERT_ID @ ��NROW_COUNT @ ��SCHEMA @ ��NUMGEOMETRIES q@ ��lLOCK TABLES !@ ��USER @ ��BVERSION @ � LINEFROMTEXT !@ � MLINEFROMTEXT "@ � MPOINTFROMTEXT #@� MPOLYFROMTEXT $@ � POINTFROMTEXT %@ POLYFROMTEXT &@ JSON_MERGE �@ JSON_REMOVE �@ �XJSON_VALID �@
JSON_STORAGE_SIZE �@ (xJSON_OBJECTAGG �@ 0�JMIN �@8 IS_IPV4_MAPPED �@ @��NAME_CONST �@ H LINEFROMWKB 1@ P�lMLINEFROMWKB 2@ X�>MPOINTFROMWKB 3@ `xMPOLYFROMWKB 4@ h �POINTFROMWKB 5@ p POLYFROMWKB 6@ xJSON_MERGE_PATCH() �@ � �JSON_REPLACE �@ ���JSON_PRETTY �@ �bJSON_ARRAYAGG �@ ���MAX �@ ��IS_IPV4 �@ ���IS_IPV6 �@ ��RENAME TABLE @ ��LINESTRING @@ � JMULTILINESTRING A@ � JMULTIPOINT B@��MULTIPOLYGON C@ ��POINT D@ ��DPOLYGON E@ �bJSON_EXTRACT �@ �PJSON_KEYS �@ ��ISEMPTY M@ � ISSIMPLE N@ ��JSON_ARRAY �@��JSON_APPEND �@ �PJSON_ARRAY_INSERT �@ �JSON_MERGE_PRESERVE() �@ (��JSON_DEPTH �@ 0�NJSON_LENGTH �@ 8�tINSERT SELECT @ @�dLOAD XML @ H� REPLACE @ P�X X@ X�Y Y@ `�>ISCLOSED \@h�TNUMPOINTS ]@ p�POINTN ^@ x��JSON_ARRAY_APPEND �@��JSON_UNQUOTE �@ ���JSON_TYPE �@ ��IS_IPV4_COMPAT �@ ���MASTER_POS_WAIT �@ ��xLOAD DATA @�� JSON_OBJECT �@ ��>INTERIORRINGN i@ �� NUMINTERIORRINGS j@ ���JSON_CONTAINS_PATH �@� �JSON_SEARCH �@��JSON_INSERT �@ ��JSON_SET � p " D ��� p��� *h�d.*<;, �5�-� �
�!(� tL$����<
>�=|>��7�007j�\ c��^V $�bH� �zE� 7�
3?
infimum supremum= {@ � "� 6WUCASE Syntax:
UCASE(str)
UCASE() is a synonym for UPPER().
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html=Ҁ&�@ � � "� 6dUNHEX Syntax:
UNHEX(str)
For a string argument str, UNHEX(str) interprets each pair of
characters in the argument as a hexadecimal number and converts it to
the byte represented by the number. The return value is a binary
string.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT UNHEX('4D7953514C');
-> 'MySQL'
mysql> SELECT X'4D7953514C';
-> 'MySQL'
mysql> SELECT UNHEX(HEX('string'));
-> 'string'
mysql> SELECT HEX(UNHEX('1267'));
-> '1267'
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= N�@ � � "� 6qUPPER Syntax:
UPPER(str)
Returns the string str with all characters changed to uppercase
according to the current character set mapping. The default is latin1
(cp1252 West European).
mysql> SELECT UPPER('Hej');
-> 'HEJ'
See the description of LOWER() for information that also applies to
UPPER(). This included information about how to perform lettercase
conversion of binary strings (BINARY, VARBINARY, BLOB) for which these
functions are ineffective, and information about case folding for
Unicode character sets.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.html= t�@ ( � "� 6~WEIGHT_STRING Syntax:
WEIGHT_STRING(str [AS {CHAR|BINARY}(N)] [LEVEL levels] [flags])
levels: N [ASC|DESC|REVERSE] [, N [ASC|DESC|REVERSE]] ...
This function returns the weight string for the input string. The
return value is a binary string that represents the comparison and
sorting value of the string. It has these properties:
o If WEIGHT_STRING(str1) = WEIGHT_STRING(str2), then str1 = str2 (str1
and str2 are considered equal)
o If WEIGHT_STRING(str1) < WEIGHT_STRING(str2), then str1 < str2 (str1
sorts before str2)
WEIGHT_STRING() is a debugging function intended for internal use. Its
behavior can change without notice between MySQL versions. It can be
used for testing and debugging of collations, especially if you are
adding a new collation. See
https://dev.mysql.com/doc/refman/5.7/en/adding-collation.html.
This list briefly summarizes the arguments. More details are given in
the discussion following the list.
o str: The input string expression.
o AS clause: Optional; cast the input string to a given type and
length.
o LEVEL clause: Optional; specify weight levels for the return value.
o flags: Optional; unused.
The input string, str, is a string expression. If the input is a
nonbinary (character) string such as a CHAR, VARCHAR, or TEXT value,
the return value contains the collation weights for the string. If the
input is a binary (byte) string such as a BINARY, VARBINARY, or BLOB
value, the return value is the same as the input (the weight for each
byte in a binary string is the byte value). If the input is NULL,
WEIGHT_STRING() returns NULL.
Examples:
mysql> SET @s = _latin1 'AB' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB | 4142 | 4142 |
+------+---------+------------------------+
mysql> SET @s = _latin1 'ab' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab | 6162 | 4142 |
+------+---------+------------------------+
mysql> SET @s = CAST('AB' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB | 4142 | 4142 |
+------+---------+------------------------+
mysql> SET @s = CAST('ab' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab | 6162 | 6162 |
+------+---------+------------------------+
URL: https://dev.mysql.com/doc/refman/5.7/en/string-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlHe��@ 0 � "� 6�LIKE Syntax:
expr LIKE pat [ESCAPE 'escape_char']
Pattern matching using an SQL pattern. Returns 1 (TRUE) or 0 (FALSE).
If either expr or pat is NULL, the result is NULL.
The pattern need not be a literal string. For example, it can be
specified as a string expression or table column. In the latter case,
the column must be defined as one of the MySQL string types (see
https://dev.mysql.com/doc/refman/5.7/en/string-types.html).
URL: https://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html
mysql> SELECT 'David!' LIKE 'David_';
-> 1
mysql> SELECT 'David!' LIKE '%D%v%';
-> 1
https://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.htmlH @ 8h � "� 6�NOT LIKE Syntax:
expr NOT LIKE pat [ESCAPE 'escape_char']
This is the same as NOT (expr LIKE pat [ESCAPE 'escape_char']).
URL: https://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html
https://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.htmlH���@ @H � "� 6�STRCMP Syntax:
STRCMP(expr1,expr2)
STRCMP() returns 0 if the strings are the same, -1 if the first
argument is smaller than the second according to the current sort
order, and 1 otherwise.
URL: https://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html
mysql> SELECT STRCMP('text', 'text2');
-> -1
mysql> SELECT STRCMP('text2', 'text');
-> 1
mysql> SELECT STRCMP('text', 'text');
-> 0
https://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html3 ��@ H( � "� 6�NOT REGEXP Syntax:
expr NOT REGEXP pat, expr NOT RLIKE pat
This is the same as NOT (expr REGEXP pat).
URL: https://dev.mysql.com/doc/refman/5.7/en/regexp.html
https://dev.mysql.com/doc/refman/5.7/en/regexp.html3O�'�@ P � "� 6�REGEXP Syntax:
expr REGEXP pat, expr RLIKE pat
Returns 1 if the string expr matches the regular expression specified
by the pattern pat, 0 otherwise. If either expr or pat is NULL, the
return value is NULL.
RLIKE is a synonym for REGEXP.
The pattern can be an extended regular expression, the syntax for which
is discussed in
https://dev.mysql.com/doc/refman/5.7/en/regexp.html#regexp-syntax. The
pattern need not be a literal string. For example, it can be specified
as a string expression or table column.
*Note*:
MySQL uses C escape syntax in strings (for example, \n to represent the
newline character). If you want your expr or pat argument to contain a
literal \, you must double it. (Unless the NO_BACKSLASH_ESCAPES SQL
mode is enabled, in which case no escape character is used.)
Regular expression operations use the character set and collation of
the string expression and pattern arguments when deciding the type of a
character and performing the comparison. If the arguments have
different character sets or collations, coercibility rules apply as
described in
https://dev.mysql.com/doc/refman/5.7/en/charset-collation-coercibility.
html. If either argument is a binary string, the arguments are handled
in case-sensitive fashion as binary strings.
URL: https://dev.mysql.com/doc/refman/5.7/en/regexp.html
mysql> SELECT 'Michael!' REGEXP '.*';
+------------------------+
| 'Michael!' REGEXP '.*' |
+------------------------+
| 1 |
+------------------------+
mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
+---------------------------------------+
| 'new*\n*line' REGEXP 'new\\*.\\*line' |
+---------------------------------------+
| 0 |
+---------------------------------------+
mysql> SELECT 'a' REGEXP '^[a-d]';
+---------------------+
| 'a' REGEXP '^[a-d]' |
+---------------------+
| 1 |
+---------------------+
https://dev.mysql.com/doc/refman/5.7/en/regexp.html<˂@ X; � "� 6�MATCH AGAINST Syntax:
MATCH (col1,col2,...) AGAINST (expr [search_modifier])
MySQL has support for full-text indexing and searching:
o A full-text index in MySQL is an index of type FULLTEXT.
o Full-text indexes can be used only with InnoDB or MyISAM tables, and
can be created only for CHAR, VARCHAR, or TEXT columns.
o MySQL provides a built-in full-text ngram parser that supports
Chinese, Japanese, and Korean (CJK), and an installable MeCab
full-text parser plugin for Japanese. Parsing differences are
outlined in
https://dev.mysql.com/doc/refman/5.7/en/fulltext-search-ngram.html,
and
https://dev.mysql.com/doc/refman/5.7/en/fulltext-search-mecab.html.
o A FULLTEXT index definition can be given in the CREATE TABLE
statement when a table is created, or added later using ALTER TABLE
or CREATE INDEX.
o For large data sets, it is much faster to load your data into a table
that has no FULLTEXT index and then create the index after that, than
to load data into a table that has an existing FULLTEXT index.
Full-text searching is performed using MATCH() AGAINST() syntax.
MATCH() takes a comma-separated list that names the columns to be
searched. AGAINST takes a string to search for, and an optional
modifier that indicates what type of search to perform. The search
string must be a string value that is constant during query evaluation.
This rules out, for example, a table column because that can differ for
each row.
There are three types of full-text searches:
o A natural language search interprets the search string as a phrase in
natural human language (a phrase in free text). There are no special
operators, with the exception of double quote (") characters. The
stopword list applies. For more information about stopword lists, see
https://dev.mysql.com/doc/refman/5.7/en/fulltext-stopwords.html.
Full-text searches are natural language searches if the IN NATURAL
LANGUAGE MODE modifier is given or if no modifier is given. For more
information, see
https://dev.mysql.com/doc/refman/5.7/en/fulltext-natural-language.htm
l.
o A boolean search interprets the search string using the rules of a
special query language. The string contains the words to search for.
It can also contain operators that specify requirements such that a
word must be present or absent in matching rows, or that it should be
weighted higher or lower than usual. Certain common words (stopwords)
are omitted from the search index and do not match if present in the
search string. The IN BOOLEAN MODE modifier specifies a boolean
search. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/fulltext-boolean.html.
o A query expansion search is a modification of a natural language
search. The search string is used to perform a natural language
search. Then words from the most relevant rows returned by the search
are added to the search string and the search is done again. The
query returns the rows from the second search. The IN NATURAL
LANGUAGE MODE WITH QUERY EXPANSION or WITH QUERY EXPANSION modifier
specifies a query expansion search. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/fulltext-query-expansion.html
.
URL: https://dev.mysql.com/doc/refman/5.7/en/fulltext-search.html
mysql> SELECT id, body, MATCH (title,body)
-> AGAINST ('Security implications of running MySQL as root'
-> IN NATURAL LANGUAGE MODE) AS score
-> FROM articles
-> WHERE MATCH (title,body)
-> AGAINST('Security implications of running MySQL as root'
-> IN NATURAL LANGUAGE MODE);
+----+-------------------------------------+-----------------+
| id | body | score |
+----+-------------------------------------+-----------------+
| 4 | 1. Never run mysqld as root. 2. ... | 1.5219271183014 |
| 6 | When configured properly, MySQL ... | 1.3114095926285 |
+----+-------------------------------------+-----------------+
2 rows in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/fulltext-search.html;����@ `�1 � "� 6�BINARY OPERATOR Syntax:
BINARY expr
The BINARY operator converts the expression to a binary string (a
string that has the binary character set and binary collation). A
common use for BINARY is to force a character string comparison to be
done byte by byte using numeric byte values rather than character by
character. The BINARY operator also causes trailing spaces in
comparisons to be significant. For information about the differences
between the binary collation of the binary character set and the _bin
collations of nonbinary character sets, see
https://dev.mysql.com/doc/refman/5.7/en/charset-binary-collations.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html
mysql> SELECT 'a' = 'A';
-> 1
mysql> SELECT BINARY 'a' = 'A';
-> 0
mysql> SELECT 'a' = 'a ';
-> 1
mysql> SELECT BINARY 'a' = 'a ';
-> 0
https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html p c�bH� �z� 5 �E� 9� 7� infimum supremum; ��@
" � "� 6�CAST Syntax:
CAST(expr AS type)
CAST(expr AS type takes an expression of any type and produces a result
value of the specified type. This operation may also be expressed as
CONVERT(expr, type), which is equivalent.
These type values are permitted:
o BINARY[(N)]
Produces a string with the VARBINARY data type, except that when the
expression expr is empty (zero length), the result type is BINARY(0).
If the optional length N is given, BINARY(N) causes the cast to use
no more than N bytes of the argument. Values shorter than N bytes are
padded with 0x00 bytes to a length of N. If the optional length N is
not given, MySQL calculates the maximum length from the expression.
If the supplied or calculated length is greater than an internal
threshold, the result type is BLOB. If the length is still too long,
the result type is LONGBLOB.
For a description of how casting to BINARY affects comparisons, see
https://dev.mysql.com/doc/refman/5.7/en/binary-varbinary.html.
o CHAR[(N)] [charset_info]
Produces a string with the VARCHAR data type, unless the expression
expr is empty (zero length), in which case the result type is
CHAR(0). If the optional length N is given, CHAR(N) causes the cast
to use no more than N characters of the argument. No padding occurs
for values shorter than N characters. If the optional length N is not
given, MySQL calculates the maximum length from the expression. If
the supplied or calculated length is greater than an internal
threshold, the result type is TEXT. If the length is still too long,
the result type is LONGTEXT.
With no charset_info clause, CHAR produces a string with the default
character set. To specify the character set explicitly, these
charset_info values are permitted:
o CHARACTER SET charset_name: Produces a string with the given
character set.
o ASCII: Shorthand for CHARACTER SET latin1.
o UNICODE: Shorthand for CHARACTER SET ucs2.
In all cases, the string has the character set default collation.
o DATE
Produces a DATE value.
o DATETIME[(M)]
Produces a DATETIME value. If the optional M value is given, it
specifies the fractional seconds precision.
o DECIMAL[(M[,D])]
Produces a DECIMAL value. If the optional M and D values are given,
they specify the maximum number of digits (the precision) and the
number of digits following the decimal point (the scale). If D is
omitted, 0 is assumed. If M is omitted, 10 is assumed.
o JSON
Produces a JSON value. For details on the rules for conversion of
values between JSON and other types, see
https://dev.mysql.com/doc/refman/5.7/en/json.html#json-comparison.
o NCHAR[(N)]
Like CHAR, but produces a string with the national character set. See
https://dev.mysql.com/doc/refman/5.7/en/charset-national.html.
Unlike CHAR, NCHAR does not permit trailing character set information
to be specified.
o SIGNED [INTEGER]
Produces a signed BIGINT value.
o TIME[(M)]
Produces a TIME value. If the optional M value is given, it specifies
the fractional seconds precision.
o UNSIGNED [INTEGER]
Produces an unsigned BIGINT value.
URL: https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html
https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html; l�@ � "� 6�CONVERT Syntax:
CONVERT(expr USING transcoding_name)
CONVERT(expr,type)
CONVERT(expr USING transcoding_name) is standard SQL syntax. The
non-USING form of CONVERT() is ODBC syntax.
CONVERT(expr USING transcoding_name) converts data between different
character sets. In MySQL, transcoding names are the same as the
corresponding character set names. For example, this statement converts
the string 'abc' in the default character set to the corresponding
string in the utf8 character set:
SELECT CONVERT('abc' USING utf8);
CONVERT(expr, type) syntax (without USING) takes an expression and a
type value specifying a result type, and produces a result value of the
specified type. This operation may also be expressed as CAST(expr AS
type), which is equivalent. For more information, see the description
of CAST().
URL: https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html
https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html:�<�@
� � "� 6 EXTRACTVALUE Syntax:
ExtractValue(xml_frag, xpath_expr)
ExtractValue() takes two string arguments, a fragment of XML markup
xml_frag and an XPath expression xpath_expr (also known as a locator);
it returns the text (CDATA) of the first text node which is a child of
the element or elements matched by the XPath expression.
Using this function is the equivalent of performing a match using the
xpath_expr after appending /text(). In other words,
ExtractValue('<a><b>Sakila</b></a>', '/a/b') and
ExtractValue('<a><b>Sakila</b></a>', '/a/b/text()') produce the same
result.
If multiple matches are found, the content of the first child text node
of each matching element is returned (in the order matched) as a
single, space-delimited string.
If no matching text node is found for the expression (including the
implicit /text())---for whatever reason, as long as xpath_expr is
valid, and xml_frag consists of elements which are properly nested and
closed---an empty string is returned. No distinction is made between a
match on an empty element and no match at all. This is by design.
If you need to determine whether no matching element was found in
xml_frag or such an element was found but contained no child text
nodes, you should test the result of an expression that uses the XPath
count() function. For example, both of these statements return an empty
string, as shown here:
mysql> SELECT ExtractValue('<a><b/></a>', '/a/b');
+-------------------------------------+
| ExtractValue('<a><b/></a>', '/a/b') |
+-------------------------------------+
| |
+-------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT ExtractValue('<a><c/></a>', '/a/b');
+-------------------------------------+
| ExtractValue('<a><c/></a>', '/a/b') |
+-------------------------------------+
| |
+-------------------------------------+
1 row in set (0.00 sec)
However, you can determine whether there was actually a matching
element using the following:
mysql> SELECT ExtractValue('<a><b/></a>', 'count(/a/b)');
+-------------------------------------+
| ExtractValue('<a><b/></a>', 'count(/a/b)') |
+-------------------------------------+
| 1 |
+-------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT ExtractValue('<a><c/></a>', 'count(/a/b)');
+-------------------------------------+
| ExtractValue('<a><c/></a>', 'count(/a/b)') |
+-------------------------------------+
| 0 |
+-------------------------------------+
1 row in set (0.01 sec)
*Important*:
ExtractValue() returns only CDATA, and does not return any tags that
might be contained within a matching tag, nor any of their content (see
the result returned as val1 in the following example).
URL: https://dev.mysql.com/doc/refman/5.7/en/xml-functions.html
mysql> SELECT
-> ExtractValue('<a>ccc<b>ddd</b></a>', '/a') AS val1,
-> ExtractValue('<a>ccc<b>ddd</b></a>', '/a/b') AS val2,
-> ExtractValue('<a>ccc<b>ddd</b></a>', '//b') AS val3,
-> ExtractValue('<a>ccc<b>ddd</b></a>', '/b') AS val4,
-> ExtractValue('<a>ccc<b>ddd</b><b>eee</b></a>', '//b') AS val5;
+------+------+------+------+---------+
| val1 | val2 | val3 | val4 | val5 |
+------+------+------+------+---------+
| ccc | ddd | ddd | | ddd eee |
+------+------+------+------+---------+
https://dev.mysql.com/doc/refman/5.7/en/xml-functions.html:v�*�@ (7 � "� 6
UPDATEXML Syntax:
UpdateXML(xml_target, xpath_expr, new_xml)
This function replaces a single portion of a given fragment of XML
markup xml_target with a new XML fragment new_xml, and then returns the
changed XML. The portion of xml_target that is replaced matches an
XPath expression xpath_expr supplied by the user.
If no expression matching xpath_expr is found, or if multiple matches
are found, the function returns the original xml_target XML fragment.
All three arguments should be strings.
URL: https://dev.mysql.com/doc/refman/5.7/en/xml-functions.html
mysql> SELECT
-> UpdateXML('<a><b>ccc</b><d></d></a>', '/a', '<e>fff</e>') AS val1,
-> UpdateXML('<a><b>ccc</b><d></d></a>', '/b', '<e>fff</e>') AS val2,
-> UpdateXML('<a><b>ccc</b><d></d></a>', '//b', '<e>fff</e>') AS val3,
-> UpdateXML('<a><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val4,
-> UpdateXML('<a><d></d><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val5
-> \G
*************************** 1. row ***************************
val1: <e>fff</e>
val2: <a><b>ccc</b><d></d></a>
val3: <a><e>fff</e><d></d></a>
val4: <a><b>ccc</b><e>fff</e></a>
val5: <a><d></d><b>ccc</b><d></d></a>
https://dev.mysql.com/doc/refman/5.7/en/xml-functions.html:%��@ 0@ � "� 6| Syntax:
|
Bitwise OR.
The result is an unsigned 64-bit integer.
URL: https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 29 | 15;
-> 31
https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html:%��@ 8A � "� 6'& Syntax:
&
Bitwise AND.
The result is an unsigned 64-bit integer.
URL: https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 29 & 15;
-> 13
https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html:g��@ @� � "� 64^ Syntax:
^
Bitwise XOR.
The result is an unsigned 64-bit integer.
URL: https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 1 ^ 1;
-> 0
mysql> SELECT 1 ^ 0;
-> 1
mysql> SELECT 11 ^ 3;
-> 8
https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html:#@�@ H� � "� 6A<< Syntax:
<<
Shifts a longlong (BIGINT) number to the left.
The result is an unsigned 64-bit integer. The value is truncated to 64
bits. In particular, if the shift count is greater or equal to the
width of an unsigned 64-bit number, the result is zero.
URL: https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 1 << 2;
-> 4
https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html:#A�@ P� � "� 6N>> Syntax:
>>
Shifts a longlong (BIGINT) number to the right.
The result is an unsigned 64-bit integer. The value is truncated to 64
bits. In particular, if the shift count is greater or equal to the
width of an unsigned 64-bit number, the result is zero.
URL: https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 4 >> 2;
-> 1
https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html:#��@ XC � "� 6[~ Syntax:
~
Invert all bits.
The result is an unsigned 64-bit integer.
URL: https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 5 & ~1;
-> 4
https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html:CҀ@ `� � "� 6hBIT_COUNT Syntax:
BIT_COUNT(N)
Returns the number of bits that are set in the argument N as an
unsigned 64-bit integer, or NULL if the argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT BIT_COUNT(29), BIT_COUNT(b'101010');
-> 4, 3
https://dev.mysql.com/doc/refman/5.7/en/bit-functions.htmlA ��@ h, � "� 6uAES_DECRYPT Syntax:
AES_DECRYPT(crypt_str,key_str[,init_vector][,kdf_name][,salt][,info |
iterations])
This function decrypts data using the official AES (Advanced Encryption
Standard) algorithm. For more information, see the description of
AES_ENCRYPT().
Statements that use AES_DECRYPT() are unsafe for statement-based
replication.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA��@ p� � "� 6�AES_ENCRYPT & (Ymysql> SET block_encryption_mode = 'aes-256-cbc';
mysql> SET @key_str = SHA2('My secret passphrase',512);
mysql> SET @init_vector = RANDOM_BYTES(16);
mysql> SET @crypt_str = AES_ENCRYPT('text',@key_str,@init_vector);
mysql> SELECT AES_DECRYPT(@crypt_str,@key_str,@init_vector);
+-----------------------------------------------+
| AES_DECRYPT(@crypt_str,@key_str,@init_vector) |
+-----------------------------------------------+
| text |
+-----------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA�s�@ x� � "� 6�COMPRESS Syntax:
COMPRESS(string_to_compress)
Compresses a string and returns the result as a binary string. This
function requires MySQL to have been compiled with a compression
library such as zlib. Otherwise, the return value is always NULL. The
compressed string can be uncompressed with UNCOMPRESS().
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT LENGTH(COMPRESS(REPEAT('a',1000)));
-> 21
mysql> SELECT LENGTH(COMPRESS(''));
-> 0
mysql> SELECT LENGTH(COMPRESS('a'));
-> 13
mysql> SELECT LENGTH(COMPRESS(REPEAT('a',16)));
-> 15
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA Ɂ@ ��� � "� 6�DECODE Syntax:
DECODE(crypt_str,pass_str)
DECODE() decrypts the encrypted string crypt_str using pass_str as the
password. crypt_str should be a string returned from ENCODE().
*Note*:
The ENCODE() and DECODE() functions are deprecated in MySQL 5.7, and
should no longer be used. Expect them to be removed in a future MySQL
release. Consider using AES_ENCRYPT() and AES_DECRYPT() instead.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html p(� � c� 5 ����� ��
(Y����Syntax:
AES_ENCRYPT(str,key_str[,init_vector][,kdf_name][,salt][,info |
iterations])
AES_ENCRYPT() and AES_DECRYPT() implement encryption and decryption of
data using the official AES (Advanced Encryption Standard) algorithm,
previously known as "Rijndael." The AES standard permits various key
lengths. By default these functions implement AES with a 128-bit key
length. Key lengths of 196 or 256 bits can be used, as described later.
The key length is a trade off between performance and security.
AES_ENCRYPT() encrypts the string str using the key string key_str, and
returns a binary string containing the encrypted output. AES_DECRYPT()
decrypts the encrypted string crypt_str using the key string key_str,
and returns the original plaintext string. If either function argument
is NULL, the function returns NULL. If AES_DECRYPT() detects invalid
data or incorrect padding, it returns NULL. However, it is possible for
AES_DECRYPT() to return a non-NULL value (possibly garbage) if the
input data or the key is invalid.
As of MySQL 5.7.40, these functions support the use of a key derivation
function (KDF) to create a cryptographically strong secret key from the
information passed in key_str. The derived key is used to encrypt and
decrypt the data, and it remains in the MySQL Server instance and is
not accessible to users. Using a KDF is highly recommended, as it
provides better security than specifying your own premade key or
deriving it by a simpler method as you use the function. The functions
support HKDF (available from OpenSSL 1.1.0), for which you can specify
an optional salt and context-specific information to include in the
keying material, and PBKDF2 (available from OpenSSL 1.0.2), for which
you can specify an optional salt and set the number of iterations used
to produce the key.
AES_ENCRYPT() and AES_DECRYPT() permit control of the block encryption
mode. The block_encryption_mode system variable controls the mode for
block-based encryption algorithms. Its default value is aes-128-ecb,
which signifies encryption using a key length of 128 bits and ECB mode.
For a description of the permitted values of this variable, see
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
The optional init_vector argument is used to provide an initialization
vector for block encryption modes that require it.
Statements that use AES_ENCRYPT() or AES_DECRYPT() are unsafe for
statement-based replication.
If AES_ENCRYPT() is invoked from within the mysql client, binary
strings display using hexadecimal notation, depending on the value of
the --binary-as-hex. For more information about that option, see
https://dev.mysql.com/doc/refman/5.7/en/mysql.html.
The arguments for the AES_ENCRYPT() and AES_DECRYPT() functions are as
follows:
o str
The string for AES_ENCRYPT() to encrypt using the key string key_str,
or (as of MySQL 5.7.40) the key derived from it by the specified KDF.
The string can be any length. Padding is automatically added to str
so it is a multiple of a block as required by block-based algorithms
such as AES. This padding is automatically removed by the
AES_DECRYPT() function.
o crypt_str
The encrypted string for AES_DECRYPT() to decrypt using the key
string key_str, or (from MySQL 5.7.40) the key derived from it by the
specified KDF. The string can be any length. The length of crypt_str
can be calculated from the length of the original string using this
formula:
16 * (trunc(string_length / 16) + 1)
o key_str
The encryption key, or the input keying material that is used as the
basis for deriving a key using a key derivation function (KDF). For
the same instance of data, use the same value of key_str for
encryption with AES_ENCRYPT() and decryption with AES_DECRYPT().
If you are using a KDF, which you can from MySQL 5.7.40, key_str can
be any arbitrary information such as a password or passphrase. In the
further arguments for the function, you specify the KDF name, then
add further options to increase the security as appropriate for the
KDF.
When you use a KDF, the function creates a cryptographically strong
secret key from the information passed in key_str and any salt or
additional information that you provide in the other arguments. The
derived key is used to encrypt and decrypt the data, and it remains
in the MySQL Server instance and is not accessible to users. Using a
KDF is highly recommended, as it provides better security than
specifying your own premade key or deriving it by a simpler method as
you use the function.
If you are not using a KDF, for a key length of 128 bits, the most
secure way to pass a key to the key_str argument is to create a truly
random 128-bit value and pass it as a binary value. For example:
INSERT INTO t
VALUES (1,AES_ENCRYPT('text',UNHEX('F3229A0B371ED2D9441B830D21A390C3')));
A passphrase can be used to generate an AES key by hashing the
passphrase. For example:
INSERT INTO t
VALUES (1,AES_ENCRYPT('text', UNHEX(SHA2('My secret passphrase',512))));
If you exceed the maximum key length of 128 bits, a warning is
returned. If you are not using a KDF, do not pass a password or
passphrase directly to key_str, hash it first. Previous versions of
this documentation suggested the former approach, but it is no longer
recommended as the examples shown here are more secure.
o init_vector
An initialization vector, for block encryption modes that require it.
The block_encryption_mode system variable controls the mode. For the
same instance of data, use the same value of init_vector for
encryption with AES_ENCRYPT() and decryption with AES_DECRYPT().
*Note*:
If you are using a KDF, you must specify an initialization vector or
a null string for this argument, in order to access the later
arguments to define the KDF.
For modes that require an initialization vector, it must be 16 bytes
or longer (bytes in excess of 16 are ignored). An error occurs if
init_vector is missing. For modes that do not require an
initialization vector, it is ignored and a warning is generated if
init_vector is specified, unless you are using a KDF.
The default value for the block_encryption_mode system variable is
aes-128-ecb, or ECB mode, which does not require an initialization
vector. The alternative permitted block encryption modes CBC, CFB1,
CFB8, CFB128, and OFB all require an initialization vector.
A random string of bytes to use for the initialization vector can be
produced by calling RANDOM_BYTES(16).
o kdf_name
The name of the key derivation function (KDF) to create a key from
the input keying material passed in key_str, and other arguments as
appropriate for the KDF. This optional argument is available from
MySQL 5.7.40.
For the same instance of data, use the same value of kdf_name for
encryption with AES_ENCRYPT() and decryption with AES_DECRYPT(). When
you specify kdf_name, you must specify init_vector, using either a
valid initialization vector, or a null string if the encryption mode
does not require an initialization vector.
The following values are supported:
o hkdf
HKDF, which is available from OpenSSL 1.1.0. HKDF extracts a
pseudorandom key from the keying material then expands it into
additional keys. With HKDF, you can specify an optional salt (salt)
and context-specific information such as application details (info)
to include in the keying material.
o pbkdf2_hmac
PBKDF2, which is available from OpenSSL 1.0.2. PBKDF2 applies a
pseudorandom function to the keying material, and repeats this
process a large number of times to produce the key. With PBKDF2,
you can specify an optional salt (salt) to include in the keying
material, and set the number of iterations used to produce the key
(iterations).
In this example, HKDF is specified as the key derivation function,
and a salt and context information are provided. The argument for the
initialization vector is included but is the empty string:
SELECT AES_ENCRYPT('mytext','mykeystring', '', 'hkdf', 'salt', 'info');
In this example, PBKDF2 is specified as the key derivation function,
a salt is provided, and the number of iterations is doubled from the
recommended minimum:
SELECT AES_ENCRYPT('mytext','mykeystring', '', 'pbkdf2_hmac','salt', '2000');
o salt
A salt to be passed to the key derivation function (KDF). This
optional argument is available from MySQL 5.7.40. Both HKDF and
PBKDF2 can use salts, and their use is recommended to help prevent
attacks based on dictionaries of common passwords or rainbow tables.
A salt consists of random data, which for security must be different
for each encryption operation. A random string of bytes to use for
the salt can be produced by calling RANDOM_BYTES(). This example
produces a 64-bit salt:
SET @salt = RANDOM_BYTES(8);
For the same instance of data, use the same value of salt for
encryption with AES_ENCRYPT() and decryption with AES_DECRYPT(). The
salt can safely be stored along with the encrypted data.
o info
Context-specific information for HKDF to include in the keying
material, such as information about the application. This optional
argument is available from MySQL 5.7.40 when you specify hkdf as the
KDF name. HKDF adds this information to the keying material specified
in key_str and the salt specified in salt to produce the key.
For the same instance of data, use the same value of info for
encryption with AES_ENCRYPT() and decryption with AES_DECRYPT().
o iterations
The iteration count for PBKDF2 to use when producing the key. This
optional argument is available from MySQL 5.7.40 when you specify
pbkdf2_hmac as the KDF name. A higher count gives greater resistance
to brute-force attacks because it has a greater computational cost
for the attacker, but the same is necessarily true for the key
derivation process. The default if you do not specify this argument
is 1000, which is the minimum recommended by the OpenSSL standard.
For the same instance of data, use the same value of iterations for
encryption with AES_ENCRYPT() and decryption with AES_DECRYPT().
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
���� �ز�B :�E� - � +c infimum supremumA n�@ � "� 6�DES_DECRYPT Syntax:
DES_DECRYPT(crypt_str[,key_str])
Decrypts a string encrypted with DES_ENCRYPT(). If an error occurs,
this function returns NULL.
This function works only if MySQL has been configured with SSL support.
See https://dev.mysql.com/doc/refman/5.7/en/encrypted-connections.html.
If no key_str argument is given, DES_DECRYPT() examines the first byte
of the encrypted string to determine the DES key number that was used
to encrypt the original string, and then reads the key from the DES key
file to decrypt the message. For this to work, the user must have the
SUPER privilege. The key file can be specified with the --des-key-file
server option.
If you pass this function a key_str argument, that string is used as
the key for decrypting the message.
If the crypt_str argument does not appear to be an encrypted string,
MySQL returns the given crypt_str.
*Note*:
The DES_ENCRYPT() and DES_DECRYPT() functions are deprecated in MySQL
5.7, are removed in MySQL 8.0, and should no longer be used. Consider
using AES_ENCRYPT() and AES_DECRYPT() instead.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlAz�@ � "� 6�DES_ENCRYPT Syntax:
DES_ENCRYPT(str[,{key_num|key_str}])
Encrypts the string with the given key using the Triple-DES algorithm.
This function works only if MySQL has been configured with SSL support.
See https://dev.mysql.com/doc/refman/5.7/en/encrypted-connections.html.
The encryption key to use is chosen based on the second argument to
DES_ENCRYPT(), if one was given. With no argument, the first key from
the DES key file is used. With a key_num argument, the given key number
(0 to 9) from the DES key file is used. With a key_str argument, the
given key string is used to encrypt str.
The key file can be specified with the --des-key-file server option.
The return string is a binary string where the first character is
CHAR(128 | key_num). If an error occurs, DES_ENCRYPT() returns NULL.
The 128 is added to make it easier to recognize an encrypted key. If
you use a string key, key_num is 127.
The string length for the result is given by this formula:
new_len = orig_len + (8 - (orig_len % 8)) + 1
Each line in the DES key file has the following format:
key_num des_key_str
Each key_num value must be a number in the range from 0 to 9. Lines in
the file may be in any order. des_key_str is the string that is used to
encrypt the message. There should be at least one space between the
number and the key. The first key is the default key that is used if
you do not specify any key argument to DES_ENCRYPT().
You can tell MySQL to read new key values from the key file with the
FLUSH DES_KEY_FILE statement. This requires the RELOAD privilege.
One benefit of having a set of default keys is that it gives
applications a way to check for the existence of encrypted column
values, without giving the end user the right to decrypt those values.
*Note*:
The DES_ENCRYPT() and DES_DECRYPT() functions are deprecated in MySQL
5.7, are removed in MySQL 8.0, and should no longer be used. Consider
using AES_ENCRYPT() and AES_DECRYPT() instead.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT customer_address FROM customer_table
> WHERE crypted_credit_card = DES_ENCRYPT('credit_card_number');
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA ~�@ "� 6�ENCODE Syntax:
ENCODE(str,pass_str)
ENCODE() encrypts str using pass_str as the password. The result is a
binary string of the same length as str. To decrypt the result, use
DECODE().
*Note*:
The ENCODE() and DECODE() functions are deprecated in MySQL 5.7, and
should no longer be used. Expect them to be removed in a future MySQL
release.
If you still need to use ENCODE(), a salt value must be used with it to
reduce risk. For example:
ENCODE('cleartext', CONCAT('my_random_salt','my_secret_password'))
A new random salt value must be used whenever a password is updated.
If ENCODE() is invoked from within the mysql client, binary strings
display using hexadecimal notation, depending on the value of the
--binary-as-hex. For more information about that option, see
https://dev.mysql.com/doc/refman/5.7/en/mysql.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA;�@ (� "� 6�ENCRYPT Syntax:
ENCRYPT(str[,salt])
Encrypts str using the Unix crypt() system call and returns a binary
string. The salt argument must be a string with at least two characters
or else the result is NULL. If no salt argument is given, a random
value is used.
*Note*:
The ENCRYPT() function is deprecated in MySQL 5.7, are removed in MySQL
8.0, and should no longer be used. For one-way hashing, consider using
SHA2() instead.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT ENCRYPT('hello');
-> 'VxuFAJXVARROc'
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlAL��@ 0� "� 6�MD5 Syntax:
MD5(str)
Calculates an MD5 128-bit checksum for the string. The value is
returned as a string of 32 hexadecimal digits, or NULL if the argument
was NULL. The return value can, for example, be used as a hash key. See
the notes at the beginning of this section about storing hash values
efficiently.
The return value is a string in the connection character set.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT MD5('testing');
-> 'ae2b1fca515949e5d54fb22b8ed95575'
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA ۂ@ 8y "� 6�PASSWORD Syntax:
PASSWORD(str)
*Note*:
This function is deprecated in MySQL 5.7 and is removed in MySQL 8.0.
Returns a hashed password string calculated from the cleartext password
str. The return value is a string in the connection character set, or
NULL if the argument is NULL. This function is the SQL interface to the
algorithm used by the server to encrypt MySQL passwords for storage in
the mysql.user grant table.
The old_passwords system variable controls the password hashing method
used by the PASSWORD() function. It also influences password hashing
performed by CREATE USER and GRANT statements that specify a password
using an IDENTIFIED BY clause.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA ��@ @� "� 6�RANDOM_BYTES Syntax:
RANDOM_BYTES(len)
This function returns a binary string of len random bytes generated
using the random number generator of the SSL library. Permitted values
of len range from 1 to 1024. For values outside that range, an error
occurs.
RANDOM_BYTES() can be used to provide the initialization vector for the
AES_DECRYPT() and AES_ENCRYPT() functions. For use in that context, len
must be at least 16. Larger values are permitted, but bytes in excess
of 16 are ignored.
RANDOM_BYTES() generates a random value, which makes its result
nondeterministic. Consequently, statements that use this function are
unsafe for statement-based replication and cannot be stored in the
query cache.
If RANDOM_BYTES() is invoked from within the mysql client, binary
strings display using hexadecimal notation, depending on the value of
the --binary-as-hex. For more information about that option, see
https://dev.mysql.com/doc/refman/5.7/en/mysql.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlAQ �@ H
"� 6SHA1 Syntax:
SHA1(str), SHA(str)
Calculates an SHA-1 160-bit checksum for the string, as described in
RFC 3174 (Secure Hash Algorithm). The value is returned as a string of
40 hexadecimal digits, or NULL if the argument was NULL. One of the
possible uses for this function is as a hash key. See the notes at the
beginning of this section about storing hash values efficiently. SHA()
is synonymous with SHA1().
The return value is a string in the connection character set.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT SHA1('abc');
-> 'a9993e364706816aba3e25717850c26c9cd0d89d'
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlAf�@ P� "� 6SHA2 Syntax:
SHA2(str, hash_length)
Calculates the SHA-2 family of hash functions (SHA-224, SHA-256,
SHA-384, and SHA-512). The first argument is the plaintext string to be
hashed. The second argument indicates the desired bit length of the
result, which must have a value of 224, 256, 384, 512, or 0 (which is
equivalent to 256). If either argument is NULL or the hash length is
not one of the permitted values, the return value is NULL. Otherwise,
the function result is a hash value containing the desired number of
bits. See the notes at the beginning of this section about storing hash
values efficiently.
The return value is a string in the connection character set.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT SHA2('abc', 224);
-> '23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7'
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA��w�@ X� "� 6 UNCOMPRESS Syntax:
UNCOMPRESS(string_to_uncompress)
Uncompresses a string compressed by the COMPRESS() function. If the
argument is not a compressed value, the result is NULL. This function
requires MySQL to have been compiled with a compression library such as
zlib. Otherwise, the return value is always NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT UNCOMPRESS(COMPRESS('any string'));
-> 'any string'
mysql> SELECT UNCOMPRESS('any string');
-> NULL
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlAKĀ@ `� "� 6+UNCOMPRESSED_LENGTH Syntax:
UNCOMPRESSED_LENGTH(compressed_string)
Returns the length that the compressed string had before being
compressed.
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
-> 30
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlA '�@ h�
"� 68VALIDATE_PASSWORD_STRENGTH Syntax:
VALIDATE_PASSWORD_STRENGTH(str)
Given an argument representing a plaintext password, this function
returns an integer to indicate how strong the password is. The return
value ranges from 0 (weak) to 100 (strong).
URL: https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
https://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html p &� c��B :��#�X |�E� 5�� ,
infimum supremum> ǎ@ b "� 6EGET_LOCK Syntax:
GET_LOCK(str,timeout)
Tries to obtain a lock with a name given by the string str, using a
timeout of timeout seconds. A negative timeout value means infinite
timeout. The lock is exclusive. While held by one session, other
sessions cannot obtain a lock of the same name.
Returns 1 if the lock was obtained successfully, 0 if the attempt timed
out (for example, because another client has previously locked the
name), or NULL if an error occurred (such as running out of memory or
the thread was killed with mysqladmin kill).
A lock obtained with GET_LOCK() is released explicitly by executing
RELEASE_LOCK() or implicitly when your session terminates (either
normally or abnormally). Locks obtained with GET_LOCK() are not
released when transactions commit or roll back.
In MySQL 5.7, GET_LOCK() was reimplemented using the metadata locking
(MDL) subsystem and its capabilities were extended. Multiple
simultaneous locks can be acquired and GET_LOCK() does not release any
existing locks.
It is even possible for a given session to acquire multiple locks for
the same name. Other sessions cannot acquire a lock with that name
until the acquiring session releases all its locks for the name.
As a result of the MDL reimplementation, uniquely named locks acquired
with GET_LOCK() appear in the Performance Schema metadata_locks table.
The OBJECT_TYPE column says USER LEVEL LOCK and the OBJECT_NAME column
indicates the lock name. In the case that multiple locks are acquired
for the same name, only the first lock for the name registers a row in
the metadata_locks table. Subsequent locks for the name increment a
counter in the lock but do not acquire additional metadata locks. The
metadata_locks row for the lock is deleted when the last lock instance
on the name is released.
The capability of acquiring multiple locks means there is the
possibility of deadlock among clients. When this happens, the server
chooses a caller and terminates its lock-acquisition request with an
ER_USER_LOCK_DEADLOCK
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_user_lock_deadlock) error. This error does not cause
transactions to roll back.
Before MySQL 5.7, only a single simultaneous lock can be acquired and
GET_LOCK() releases any existing lock. The difference in lock
acquisition behavior as of MySQL 5.7 can be seen by the following
example. Suppose that you execute these statements:
SELECT GET_LOCK('lock1',10);
SELECT GET_LOCK('lock2',10);
SELECT RELEASE_LOCK('lock2');
SELECT RELEASE_LOCK('lock1');
In MySQL 5.7 or later, the second GET_LOCK() acquires a second lock and
both RELEASE_LOCK() calls return 1 (success). Before MySQL 5.7, the
second GET_LOCK() releases the first lock ('lock1') and the second
RELEASE_LOCK() returns NULL (failure) because there is no 'lock1' to
release.
MySQL 5.7 and later enforces a maximum length on lock names of 64
characters. Previously, no limit was enforced.
GET_LOCK() can be used to implement application locks or to simulate
record locks. Names are locked on a server-wide basis. If a name has
been locked within one session, GET_LOCK() blocks any request by
another session for a lock with the same name. This enables clients
that agree on a given lock name to use the name to perform cooperative
advisory locking. But be aware that it also enables a client that is
not among the set of cooperating clients to lock a name, either
inadvertently or deliberately, and thus prevent any of the cooperating
clients from locking that name. One way to reduce the likelihood of
this is to use lock names that are database-specific or
application-specific. For example, use lock names of the form
db_name.str or app_name.str.
URL: https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html
https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html> 9�@ � "� 6RIS_FREE_LOCK Syntax:
IS_FREE_LOCK(str)
Checks whether the lock named str is free to use (that is, not locked).
Returns 1 if the lock is free (no one is using the lock), 0 if the lock
is in use, and NULL if an error occurs (such as an incorrect argument).
URL: https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html
https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html> �@ �
"� 6_IS_USED_LOCK Syntax:
IS_USED_LOCK(str)
Checks whether the lock named str is in use (that is, locked). If so,
it returns the connection identifier of the client session that holds
the lock. Otherwise, it returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html
https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html> @ (s "� 6lRELEASE_ALL_LOCKS Syntax:
RELEASE_ALL_LOCKS()
Releases all named locks held by the current session and returns the
number of locks released (0 if there were none)
URL: https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html
https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html> �@ 0� "� 6yRELEASE_LOCK Syntax:
RELEASE_LOCK(str)
Releases the lock named by the string str that was obtained with
GET_LOCK(). Returns 1 if the lock was released, 0 if the lock was not
established by this thread (in which case the lock is not released),
and NULL if the named lock did not exist. The lock does not exist if it
was never obtained by a call to GET_LOCK() or if it has previously been
released.
The DO statement is convenient to use with RELEASE_LOCK(). See [HELP
DO].
URL: https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html
https://dev.mysql.com/doc/refman/5.7/en/locking-functions.htmlBg���@ 8� "� 6�BENCHMARK Syntax:
BENCHMARK(count,expr)
The BENCHMARK() function executes the expression expr repeatedly count
times. It may be used to time how quickly MySQL processes the
expression. The result value is 0, or NULL for inappropriate arguments
such as a NULL or negative repeat count.
The intended use is from within the mysql client, which reports query
execution times:
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye'));
+---------------------------------------------------+
| BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye')) |
+---------------------------------------------------+
| 0 |
+---------------------------------------------------+
1 row in set (4.74 sec)
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB����@ @� "� 6�CHARSET Syntax:
CHARSET(str)
Returns the character set of the string argument.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT CHARSET('abc');
-> 'latin1'
mysql> SELECT CHARSET(CONVERT('abc' USING utf8));
-> 'utf8'
mysql> SELECT CHARSET(USER());
-> 'utf8'
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlBڀ��@ H "� 6�COERCIBILITY Syntax:
COERCIBILITY(str)
Returns the collation coercibility value of the string argument.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
-> 0
mysql> SELECT COERCIBILITY(USER());
-> 3
mysql> SELECT COERCIBILITY('abc');
-> 4
mysql> SELECT COERCIBILITY(1000);
-> 5
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB����@ P� "� 6�COLLATION Syntax:
COLLATION(str)
Returns the collation of the string argument.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT COLLATION('abc');
-> 'latin1_swedish_ci'
mysql> SELECT COLLATION(_utf8'abc');
-> 'utf8_general_ci'
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB0�@ X� "� 6�CONNECTION_ID Syntax:
CONNECTION_ID()
Returns the connection ID (thread ID) for the connection. Every
connection has an ID that is unique among the set of currently
connected clients.
The value returned by CONNECTION_ID() is the same type of value as
displayed in the ID column of the Information Schema PROCESSLIST table,
the Id column of SHOW PROCESSLIST output, and the PROCESSLIST_ID column
of the Performance Schema threads table.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT CONNECTION_ID();
-> 23786
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlBр��@ ` "� 6�CURRENT_USER Syntax:
CURRENT_USER, CURRENT_USER()
Returns the user name and host name combination for the MySQL account
that the server used to authenticate the current client. This account
determines your access privileges. The return value is a string in the
utf8 character set.
The value of CURRENT_USER() can differ from the value of USER().
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT USER();
-> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
ERROR 1044: Access denied for user ''@'localhost' to
database 'mysql'
mysql> SELECT CURRENT_USER();
-> '@localhost'
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB,��@ hw "� 6�DATABASE Syntax:
DATABASE()
Returns the default (current) database name as a string in the utf8
character set. If there is no default database, DATABASE() returns
NULL. Within a stored routine, the default database is the database
that the routine is associated with, which is not necessarily the same
as the database that is the default in the calling context.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT DATABASE();
-> 'test'
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlBn�@ p� "� 6�FOUND_ROWS Syntax:
FOUND_ROWS()
A SELECT statement may include a LIMIT clause to restrict the number of
rows the server returns to the client. In some cases, it is desirable
to know how many rows the statement would have returned without the
LIMIT, but without running the statement again. To obtain this row
count, include an SQL_CALC_FOUND_ROWS option in the SELECT statement,
and then invoke FOUND_ROWS() afterward:
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
-> WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB ݈@ x�Q "� 6�LAST_INSERT_ID Syntax:
LAST_INSERT_ID(), LAST_INSERT_ID(expr)
With no argument, LAST_INSERT_ID() returns a BIGINT UNSIGNED (64-bit)
value representing the first automatically generated value successfully
inserted for an AUTO_INCREMENT column as a result of the most recently
executed INSERT statement. The value of LAST_INSERT_ID() remains
unchanged if no rows are successfully inserted.
With an argument, LAST_INSERT_ID() returns an unsigned integer.
For example, after inserting a row that generates an AUTO_INCREMENT
value, you can get the value like this:
mysql> SELECT LAST_INSERT_ID();
-> 195
The currently executing statement does not affect the value of
LAST_INSERT_ID(). Suppose that you generate an AUTO_INCREMENT value
with one statement, and then refer to LAST_INSERT_ID() in a
multiple-row INSERT statement that inserts rows into a table with its
own AUTO_INCREMENT column. The value of LAST_INSERT_ID() remains stable
in the second statement; its value for the second and later rows is not
affected by the earlier row insertions. (However, if you mix references
to LAST_INSERT_ID() and LAST_INSERT_ID(expr), the effect is undefined.)
If the previous statement returned an error, the value of
LAST_INSERT_ID() is undefined. For transactional tables, if the
statement is rolled back due to an error, the value of LAST_INSERT_ID()
is left undefined. For manual ROLLBACK, the value of LAST_INSERT_ID()
is not restored to that before the transaction; it remains as it was at
the point of the ROLLBACK.
Within the body of a stored routine (procedure or function) or a
trigger, the value of LAST_INSERT_ID() changes the same way as for
statements executed outside the body of these kinds of objects. The
effect of a stored routine or trigger upon the value of
LAST_INSERT_ID() that is seen by following statements depends on the
kind of routine:
o If a stored procedure executes statements that change the value of
LAST_INSERT_ID(), the changed value is seen by statements that follow
the procedure call.
o For stored functions and triggers that change the value, the value is
restored when the function or trigger ends, so statements following
them do not see a changed value.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
https://dev.mysql.com/doc/refman/5.7/en/information-functions.html p f c�#�X |�o�� �uE� :π 9 infimum supremumBȁ#�@ � "� 6�ROW_COUNT Syntax:
ROW_COUNT()
ROW_COUNT() returns a value as follows:
o DDL statements: 0. This applies to statements such as CREATE TABLE or
DROP TABLE.
o DML statements other than SELECT: The number of affected rows. This
applies to statements such as UPDATE, INSERT, or DELETE (as before),
but now also to statements such as ALTER TABLE and LOAD DATA.
o SELECT: -1 if the statement returns a result set, or the number of
rows "affected" if it does not. For example, for SELECT * FROM t1,
ROW_COUNT() returns -1. For SELECT * FROM t1 INTO OUTFILE
'file_name', ROW_COUNT() returns the number of rows written to the
file.
o SIGNAL statements: 0.
For UPDATE statements, the affected-rows value by default is the number
of rows actually changed. If you specify the CLIENT_FOUND_ROWS flag to
mysql_real_connect()
(https://dev.mysql.com/doc/c-api/5.7/en/mysql-real-connect.html) when
connecting to mysqld, the affected-rows value is the number of rows
"found"; that is, matched by the WHERE clause.
For REPLACE statements, the affected-rows value is 2 if the new row
replaced an old row, because in this case, one row was inserted after
the duplicate was deleted.
For INSERT ... ON DUPLICATE KEY UPDATE statements, the affected-rows
value per row is 1 if the row is inserted as a new row, 2 if an
existing row is updated, and 0 if an existing row is set to its current
values. If you specify the CLIENT_FOUND_ROWS flag, the affected-rows
value is 1 (not 0) if an existing row is set to its current values.
The ROW_COUNT() value is similar to the value from the
mysql_affected_rows()
(https://dev.mysql.com/doc/c-api/5.7/en/mysql-affected-rows.html) C API
function and the row count that the mysql client displays following
statement execution.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
| 3 |
+-------------+
1 row in set (0.00 sec)
mysql> DELETE FROM t WHERE i IN(1,2);
Query OK, 2 rows affected (0.00 sec)
mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
| 2 |
+-------------+
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB ��@ & "� 6SCHEMA Syntax:
SCHEMA()
This function is a synonym for DATABASE().
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB ��@ ) "� 6SESSION_USER Syntax:
SESSION_USER()
SESSION_USER() is a synonym for USER().
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB ��@ (' "� 6"SYSTEM_USER Syntax:
SYSTEM_USER()
SYSTEM_USER() is a synonym for USER().
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB4��@ 0� "� 6/USER Syntax:
USER()
Returns the current MySQL user name and host name as a string in the
utf8 character set.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT USER();
-> 'davida@localhost'
https://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB6|�@ 8Q "� 6<VERSION Syntax:
VERSION()
Returns a string that indicates the MySQL server version. The string
uses the utf8 character set. The value might have a suffix in addition
to the version number. See the description of the version system
variable in
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT VERSION();
-> '5.7.44-standard'
https://dev.mysql.com/doc/refman/5.7/en/information-functions.html> e�@ @ "� 6IGEOMCOLLFROMTEXT GeomCollFromText(wkt [, srid]), GeometryCollectionFromText(wkt [,
srid])
ST_GeomCollFromText(), ST_GeometryCollectionFromText(),
ST_GeomCollFromTxt(), GeomCollFromText(), and
GeometryCollectionFromText() are synonyms. For more information, see
the description of ST_GeomCollFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> !�@ H� "� 6VGEOMFROMTEXT GeomFromText(wkt [, srid]), GeometryFromText(wkt [, srid])
ST_GeomFromText(), ST_GeometryFromText(), GeomFromText(), and
GeometryFromText() are synonyms. For more information, see the
description of ST_GeomFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> '�@ P� ! "� 6cLINEFROMTEXT LineFromText(wkt [, srid]), LineStringFromText(wkt [, srid])
ST_LineFromText(), ST_LineStringFromText(), LineFromText(), and
LineStringFromText() are synonyms. For more information, see the
description of ST_LineFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> :�@ X� " "� 6pMLINEFROMTEXT MLineFromText(wkt [, srid]), MultiLineStringFromText(wkt [, srid])
ST_MLineFromText(), ST_MultiLineStringFromText(), MLineFromText(), and
MultiLineStringFromText() are synonyms. For more information, see the
description of ST_MLineFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> /�@ `� # "� 6}MPOINTFROMTEXT MPointFromText(wkt [, srid]), MultiPointFromText(wkt [, srid])
ST_MPointFromText(), ST_MultiPointFromText(), MPointFromText(), and
MultiPointFromText() are synonyms. For more information, see the
description of ST_MPointFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> 1�@ h� $ "� 6�MPOLYFROMTEXT MPolyFromText(wkt [, srid]), MultiPolygonFromText(wkt [, srid])
ST_MPolyFromText(), ST_MultiPolygonFromText(), MPolyFromText(), and
MultiPolygonFromText() are synonyms. For more information, see the
description of ST_MPolyFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> ـ@ pt % "� 6�POINTFROMTEXT PointFromText(wkt [, srid])
ST_PointFromText() and PointFromText() are synonyms. For more
information, see the description of ST_PointFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> �@ x� & "� 6�POLYFROMTEXT PolyFromText(wkt [, srid]), PolygonFromText(wkt [, srid])
ST_PolyFromText(), ST_PolygonFromText(), PolyFromText(), and
PolygonFromText() are synonyms. For more information, see the
description of ST_PolyFromText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html>^���@ �� ' "� 6�ST_GEOMCOLLFROMTEXT ST_GeomCollFromText(wkt [, srid]), ST_GeometryCollectionFromText(wkt [,
srid]), ST_GeomCollFromTxt(wkt [, srid])
Constructs a GeometryCollection value using its WKT representation and
SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
mysql> SET @g = "MULTILINESTRING((10 10, 11 11), (9 9, 10 10))";
mysql> SELECT ST_AsText(ST_GeomCollFromText(@g));
+--------------------------------------------+
| ST_AsText(ST_GeomCollFromText(@g)) |
+--------------------------------------------+
| MULTILINESTRING((10 10,11 11),(9 9,10 10)) |
+--------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> a�@ �� ( "� 6�ST_GEOMFROMTEXT ST_GeomFromText(wkt [, srid]), ST_GeometryFromText(wkt [, srid])
Constructs a geometry value of any type using its WKT representation
and SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> Y�@ �� ) "� 6�ST_LINEFROMTEXT ST_LineFromText(wkt [, srid]), ST_LineStringFromText(wkt [, srid])
Constructs a LineString value using its WKT representation and SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> d�@ �� * "� 6�ST_MLINEFROMTEXT ST_MLineFromText(wkt [, srid]), ST_MultiLineStringFromText(wkt [,
srid])
Constructs a MultiLineString value using its WKT representation and
SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> ��@ �[ + "� 6�ST_MPOINTFROMTEXT ST_MPointFromText(wkt [, srid]), ST_MultiPointFromText(wkt [, srid])
Constructs a MultiPoint value using its WKT representation and SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
Functions such as ST_MPointFromText() and ST_GeomFromText() that accept
WKT-format representations of MultiPoint values permit individual
points within values to be surrounded by parentheses. For example, both
of the following function calls are valid:
ST_MPointFromText('MULTIPOINT (1 1, 2 2, 3 3)')
ST_MPointFromText('MULTIPOINT ((1 1), (2 2), (3 3))')
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> ^�@ �� , "� 6�ST_MPOLYFROMTEXT ST_MPolyFromText(wkt [, srid]), ST_MultiPolygonFromText(wkt [, srid])
Constructs a MultiPolygon value using its WKT representation and SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> 0�@ �� - "� 6�ST_POINTFROMTEXT ST_PointFromText(wkt [, srid])
Constructs a Point value using its WKT representation and SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> S�@ �� . "� 6 ST_POLYFROMTEXT ST_PolyFromText(wkt [, srid]), ST_PolygonFromText(wkt [, srid])
Constructs a Polygon value using its WKT representation and SRID.
If the geometry argument is NULL or not a syntactically well-formed
geometry, or if the SRID argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> H�@ �� / "� 6GEOMCOLLFROMWKB GeomCollFromWKB(wkb [, srid]), GeometryCollectionFromWKB(wkb [, srid])
ST_GeomCollFromWKB(), ST_GeometryCollectionFromWKB(),
GeomCollFromWKB(), and GeometryCollectionFromWKB() are synonyms. For
more information, see the description of ST_GeomCollFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ �� 0 "� 6&GEOMFROMWKB GeomFromWKB(wkb [, srid]), GeometryFromWKB(wkb [, srid])
ST_GeomFromWKB(), ST_GeometryFromWKB(), GeomFromWKB(), and
GeometryFromWKB() are synonyms. For more information, see the
description of ST_GeomFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ �� 1 "� 63LINEFROMWKB LineFromWKB(wkb [, srid]), LineStringFromWKB(wkb [, srid])
ST_LineFromWKB(), ST_LineStringFromWKB(), LineFromWKB(), and
LineStringFromWKB() are synonyms. For more information, see the
description of ST_LineFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> 3�@ �� 2 "� 6@MLINEFROMWKB MLineFromWKB(wkb [, srid]), MultiLineStringFromWKB(wkb [, srid])
ST_MLineFromWKB(), ST_MultiLineStringFromWKB(), MLineFromWKB(), and
MultiLineStringFromWKB() are synonyms. For more information, see the
description of ST_MLineFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> (�@ ��Z 3 "� 6MMPOINTFROMWKB MPointFromWKB(wkb [, srid]), MultiPointFromWKB(wkb [, srid])
ST_MPointFromWKB(), ST_MultiPointFromWKB(), MPointFromWKB(), and
MultiPointFromWKB() are synonyms. For more information, see the
description of ST_MPointFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html p,C"�wZ \ co�� �u �Ki �E� ;Ā! 8� infimum supremum> *�@ � 4 "� 6ZMPOLYFROMWKB MPolyFromWKB(wkb [, srid]), MultiPolygonFromWKB(wkb [, srid])
ST_MPolyFromWKB(), ST_MultiPolygonFromWKB(), MPolyFromWKB(), and
MultiPolygonFromWKB() are synonyms. For more information, see the
description of ST_MPolyFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> Հ@ p 5 "� 6gPOINTFROMWKB PointFromWKB(wkb [, srid])
ST_PointFromWKB() and PointFromWKB() are synonyms. For more
information, see the description of ST_PointFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ � 6 "� 6tPOLYFROMWKB PolyFromWKB(wkb [, srid]), PolygonFromWKB(wkb [, srid])
ST_PolyFromWKB(), ST_PolygonFromWKB(), PolyFromWKB(), and
PolygonFromWKB() are synonyms. For more information, see the
description of ST_PolyFromWKB().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ (� 7 "� 6�ST_GEOMCOLLFROMWKB ST_GeomCollFromWKB(wkb [, srid]), ST_GeometryCollectionFromWKB(wkb [,
srid])
Constructs a GeometryCollection value using its WKB representation and
SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ 0� 8 "� 6�ST_GEOMFROMWKB ST_GeomFromWKB(wkb [, srid]), ST_GeometryFromWKB(wkb [, srid])
Constructs a geometry value of any type using its WKB representation
and SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ 8� 9 "� 6�ST_LINEFROMWKB ST_LineFromWKB(wkb [, srid]), ST_LineStringFromWKB(wkb [, srid])
Constructs a LineString value using its WKB representation and SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ @� : "� 6�ST_MLINEFROMWKB ST_MLineFromWKB(wkb [, srid]), ST_MultiLineStringFromWKB(wkb [, srid])
Constructs a MultiLineString value using its WKB representation and
SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ H� ; "� 6�ST_MPOINTFROMWKB ST_MPointFromWKB(wkb [, srid]), ST_MultiPointFromWKB(wkb [, srid])
Constructs a MultiPoint value using its WKB representation and SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ P� < "� 6�ST_MPOLYFROMWKB ST_MPolyFromWKB(wkb [, srid]), ST_MultiPolygonFromWKB(wkb [, srid])
Constructs a MultiPolygon value using its WKB representation and SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> ހ@ Xy = "� 6�ST_POINTFROMWKB ST_PointFromWKB(wkb [, srid])
Constructs a Point value using its WKB representation and SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html> �@ `� > "� 6�ST_POLYFROMWKB ST_PolyFromWKB(wkb [, srid]), ST_PolygonFromWKB(wkb [, srid])
Constructs a Polygon value using its WKB representation and SRID.
The result is NULL if the WKB or SRID argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlI ��@ h5 ? "� 6�GEOMETRYCOLLECTION GeometryCollection(g [, g] ...)
Constructs a GeometryCollection value from the geometry arguments.
GeometryCollection() returns all the proper geometries contained in the
arguments even if a nonsupported geometry is present.
GeometryCollection() with no arguments is permitted as a way to create
an empty geometry.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlI �@ p� @ "� 6�LINESTRING LineString(pt [, pt] ...)
Constructs a LineString value from a number of Point or WKB Point
arguments. If the number of arguments is less than two, the return
value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlI @ xh A "� 6MULTILINESTRING MultiLineString(ls [, ls] ...)
Constructs a MultiLineString value using LineString or WKB LineString
arguments.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlI ��@ �U B "� 6MULTIPOINT MultiPoint(pt [, pt2] ...)
Constructs a MultiPoint value using Point or WKB Point arguments.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlI @ �h C "� 6 MULTIPOLYGON MultiPolygon(poly [, poly] ...)
Constructs a MultiPolygon value from a set of Polygon or WKB Polygon
arguments.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlI ��@ �. D "� 6*POINT Point(x, y)
Constructs a Point using its coordinates.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlI 6�@ �� E "� 67POLYGON Polygon(ls [, ls] ...)
Constructs a Polygon value from a number of LineString or WKB
LineString arguments. If any argument does not represent a LinearRing
(that is, not a closed and simple LineString), the return value is
NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlL �@ �� F "� 6DASBINARY AsBinary(g), AsWKB(g)
ST_AsBinary(), ST_AsWKB(), AsBinary(), and AsWKB() are synonyms. For
more information, see the description of ST_AsBinary().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.htmlL �@ �� G "� 6QASTEXT AsText(g), AsWKT(g)
ST_AsText(), ST_AsWKT(), AsText(), and AsWKT() are synonyms. For more
information, see the description of ST_AsText().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.htmlL!ԁ@ �� H "� 6^ST_ASBINARY ST_AsBinary(g), ST_AsWKB(g)
Converts a value in internal geometry format to its WKB representation
and returns the binary result.
If the argument is NULL, the return value is NULL. If the argument is
not a syntactically well-formed geometry, an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_invalid_data) error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html
SELECT ST_AsBinary(g) FROM geom;
https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.htmlL�ҁ@ �� I "� 6kST_ASTEXT ST_AsText(g), ST_AsWKT(g)
Converts a value in internal geometry format to its WKT representation
and returns the string result.
If the argument is NULL, the return value is NULL. If the argument is
not a syntactically well-formed geometry, an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_invalid_data) error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html
mysql> SET @g = 'LineString(1 1,2 2,3 3)';
mysql> SELECT ST_AsText(ST_GeomFromText(@g));
+--------------------------------+
| ST_AsText(ST_GeomFromText(@g)) |
+--------------------------------+
| LINESTRING(1 1,2 2,3 3) |
+--------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.htmlK ˀ@ �s J "� 6xDIMENSION Dimension(g)
ST_Dimension() and Dimension() are synonyms. For more information, see
the description of ST_Dimension().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK ǀ@ �o K "� 6�ENVELOPE Envelope(g)
ST_Envelope() and Envelope() are synonyms. For more information, see
the description of ST_Envelope().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK ׀@ � L "� 6�GEOMETRYTYPE GeometryType(g)
ST_GeometryType() and GeometryType() are synonyms. For more
information, see the description of ST_GeometryType().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK À@ �k M "� 6�ISEMPTY IsEmpty(g)
ST_IsEmpty() and IsEmpty() are synonyms. For more information, see the
description of ST_IsEmpty().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK ǀ@ �o N "� 6�ISSIMPLE IsSimple(g)
ST_IsSimple() and IsSimple() are synonyms. For more information, see
the description of ST_IsSimple().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK ��@ �` O "� 6�SRID SRID(g)
ST_SRID() and SRID() are synonyms. For more information, see the
description of ST_SRID().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlKa�M�@ �V P "� 6�ST_DIMENSION ST_Dimension(g)
Returns the inherent dimension of the geometry value g, or NULL if the
argument is NULL. The dimension can be −1, 0, 1, or 2. The meaning of
these values is given in
https://dev.mysql.com/doc/refman/5.7/en/gis-class-geometry.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
mysql> SELECT ST_Dimension(ST_GeomFromText('LineString(1 1,2 2)'));
+------------------------------------------------------+
| ST_Dimension(ST_GeomFromText('LineString(1 1,2 2)')) |
+------------------------------------------------------+
| 1 |
+------------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK \�@ � Q "� 6�ST_ENVELOPE ST_Envelope(g)
Returns the minimum bounding rectangle (MBR) for the geometry value g,
or NULL if the argument is NULL. The result is returned as a Polygon
value that is defined by the corner points of the bounding box:
POLYGON((MINX MINY, MAXX MINY, MAXX MAXY, MINX MAXY, MINX MINY))
mysql> SELECT ST_AsText(ST_Envelope(ST_GeomFromText('LineString(1 1,2 2)')));
+----------------------------------------------------------------+
| ST_AsText(ST_Envelope(ST_GeomFromText('LineString(1 1,2 2)'))) |
+----------------------------------------------------------------+
| POLYGON((1 1,2 1,2 2,1 2,1 1)) |
+----------------------------------------------------------------+
If the argument is a point or a vertical or horizontal line segment,
ST_Envelope() returns the point or the line segment as its MBR rather
than returning an invalid polygon:
mysql> SELECT ST_AsText(ST_Envelope(ST_GeomFromText('LineString(1 1,1 2)')));
+----------------------------------------------------------------+
| ST_AsText(ST_Envelope(ST_GeomFromText('LineString(1 1,1 2)'))) |
+----------------------------------------------------------------+
| LINESTRING(1 1,1 2) |
+----------------------------------------------------------------+
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK=�<�@ �� R "� 6�ST_GEOMETRYTYPE ST_GeometryType(g)
Returns a binary string indicating the name of the geometry type of
which the geometry instance g is a member, or NULL if the argument is
NULL. The name corresponds to one of the instantiable Geometry
subclasses.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
mysql> SELECT ST_GeometryType(ST_GeomFromText('POINT(1 1)'));
+------------------------------------------------+
| ST_GeometryType(ST_GeomFromText('POINT(1 1)')) |
+------------------------------------------------+
| POINT |
+------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html p(* q i c �Ki ��XRR x,E� ;-� 5� infimum supremumK /�@ � S "� 6�ST_ISEMPTY ST_IsEmpty(g)
This function is a placeholder that returns 0 for any valid geometry
value, 1 for any invalid geometry value, or NULL if the argument is
NULL.
MySQL does not support GIS EMPTY values such as POINT EMPTY.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK �@ � T "� 6�ST_ISSIMPLE ST_IsSimple(g)
Returns 1 if the geometry value g has no anomalous geometric points,
such as self-intersection or self-tangency. ST_IsSimple() returns 0 if
the argument is not simple, and NULL if the argument is NULL.
The descriptions of the instantiable geometric classes given under
https://dev.mysql.com/doc/refman/5.7/en/opengis-geometry-model.html
includes the specific conditions that cause class instances to be
classified as not simple.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlK[��@ � U "� 6ST_SRID ST_SRID(g)
Returns an integer indicating the spatial reference system ID
associated with the geometry value g, or NULL if the argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
mysql> SELECT ST_SRID(ST_GeomFromText('LineString(1 1,2 2)',101));
+-----------------------------------------------------+
| ST_SRID(ST_GeomFromText('LineString(1 1,2 2)',101)) |
+-----------------------------------------------------+
| 101 |
+-----------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlI����@ ( V "� 6ST_X ST_X(p)
Returns the X-coordinate value for the Point object p as a
double-precision number.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html
mysql> SELECT ST_X(Point(56.7, 53.34));
+--------------------------+
| ST_X(Point(56.7, 53.34)) |
+--------------------------+
| 56.7 |
+--------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.htmlI����@ 0
W "� 6!ST_Y ST_Y(p)
Returns the Y-coordinate value for the Point object p as a
double-precision number.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html
mysql> SELECT ST_Y(Point(56.7, 53.34));
+--------------------------+
| ST_Y(Point(56.7, 53.34)) |
+--------------------------+
| 53.34 |
+--------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.htmlI ��@ 8O X "� 6.X X(p)
ST_X() and X() are synonyms. For more information, see the description
of ST_X().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.htmlI ��@ @O Y "� 6;Y Y(p)
ST_Y() and Y() are synonyms. For more information, see the description
of ST_Y().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.htmlN ˀ@ Hv Z "� 6HENDPOINT EndPoint(ls)
ST_EndPoint() and EndPoint() are synonyms. For more information, see
the description of ST_EndPoint().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN �@ P� [ "� 6UGLENGTH GLength(ls)
GLength() is a nonstandard name. It corresponds to the OpenGIS
ST_Length() function. (There is an existing SQL function Length() that
calculates the length of string values.)
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN ˀ@ Xv \ "� 6bISCLOSED IsClosed(ls)
ST_IsClosed() and IsClosed() are synonyms. For more information, see
the description of ST_IsClosed().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN π@ `z ] "� 6oNUMPOINTS NumPoints(ls)
ST_NumPoints() and NumPoints() are synonyms. For more information, see
the description of ST_NumPoints().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN ƀ@ hr ^ "� 6|POINTN PointN(ls, N)
ST_PointN() and PointN() are synonyms. For more information, see the
description of ST_PointN().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN]��@ p� _ "� 6�ST_ENDPOINT ST_EndPoint(ls)
Returns the Point that is the endpoint of the LineString value ls. If
the argument is NULL or an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
mysql> SET @ls = 'LineString(1 1,2 2,3 3)';
mysql> SELECT ST_AsText(ST_EndPoint(ST_GeomFromText(@ls)));
+----------------------------------------------+
| ST_AsText(ST_EndPoint(ST_GeomFromText(@ls))) |
+----------------------------------------------+
| POINT(3 3) |
+----------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN���@ x> ` "� 6�ST_ISCLOSED ST_IsClosed(ls)
For a LineString value ls, ST_IsClosed() returns 1 if ls is closed
(that is, its ST_StartPoint() and ST_EndPoint() values are the same).
If the argument is NULL or an empty geometry, the return value is NULL.
For a MultiLineString value ls, ST_IsClosed() returns 1 if ls is closed
(that is, the ST_StartPoint() and ST_EndPoint() values are the same for
each LineString in ls).
ST_IsClosed() returns 0 if ls is not closed.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
mysql> SET @ls1 = 'LineString(1 1,2 2,3 3,2 2)';
mysql> SET @ls2 = 'LineString(1 1,2 2,3 3,1 1)';
mysql> SELECT ST_IsClosed(ST_GeomFromText(@ls1));
+------------------------------------+
| ST_IsClosed(ST_GeomFromText(@ls1)) |
+------------------------------------+
| 0 |
+------------------------------------+
mysql> SELECT ST_IsClosed(ST_GeomFromText(@ls2));
+------------------------------------+
| ST_IsClosed(ST_GeomFromText(@ls2)) |
+------------------------------------+
| 1 |
+------------------------------------+
mysql> SET @ls3 = 'MultiLineString((1 1,2 2,3 3),(4 4,5 5))';
mysql> SELECT ST_IsClosed(ST_GeomFromText(@ls3));
+------------------------------------+
| ST_IsClosed(ST_GeomFromText(@ls3)) |
+------------------------------------+
| 0 |
+------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN7���@ �| a "� 6�ST_LENGTH ST_Length(ls)
Returns a double-precision number indicating the length of the
LineString or MultiLineString value ls in its associated spatial
reference system. The length of a MultiLineString value is equal to the
sum of the lengths of its elements. If the argument is NULL or an empty
geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
mysql> SET @ls = 'LineString(1 1,2 2,3 3)';
mysql> SELECT ST_Length(ST_GeomFromText(@ls));
+---------------------------------+
| ST_Length(ST_GeomFromText(@ls)) |
+---------------------------------+
| 2.8284271247461903 |
+---------------------------------+
mysql> SET @mls = 'MultiLineString((1 1,2 2,3 3),(4 4,5 5))';
mysql> SELECT ST_Length(ST_GeomFromText(@mls));
+----------------------------------+
| ST_Length(ST_GeomFromText(@mls)) |
+----------------------------------+
| 4.242640687119286 |
+----------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN!��@ �� b "� 6�ST_NUMPOINTS ST_NumPoints(ls)
Returns the number of Point objects in the LineString value ls. If the
argument is NULL or an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
mysql> SET @ls = 'LineString(1 1,2 2,3 3)';
mysql> SELECT ST_NumPoints(ST_GeomFromText(@ls));
+------------------------------------+
| ST_NumPoints(ST_GeomFromText(@ls)) |
+------------------------------------+
| 3 |
+------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN]�"�@ �+ c "� 6�ST_POINTN ST_PointN(ls, N)
Returns the N-th Point in the Linestring value ls. Points are numbered
beginning with 1. If any argument is NULL or the geometry argument is
an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
mysql> SET @ls = 'LineString(1 1,2 2,3 3)';
mysql> SELECT ST_AsText(ST_PointN(ST_GeomFromText(@ls),2));
+----------------------------------------------+
| ST_AsText(ST_PointN(ST_GeomFromText(@ls),2)) |
+----------------------------------------------+
| POINT(2 2) |
+----------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlNi���@ � d "� 6�ST_STARTPOINT ST_StartPoint(ls)
Returns the Point that is the start point of the LineString value ls.
If the argument is NULL or an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
mysql> SET @ls = 'LineString(1 1,2 2,3 3)';
mysql> SELECT ST_AsText(ST_StartPoint(ST_GeomFromText(@ls)));
+------------------------------------------------+
| ST_AsText(ST_StartPoint(ST_GeomFromText(@ls))) |
+------------------------------------------------+
| POINT(1 1) |
+------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN Ӏ@ �~ e "� 6�STARTPOINT StartPoint(ls)
ST_StartPoint() and StartPoint() are synonyms. For more information,
see the description of ST_StartPoint().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlK @ �j f "� 6�AREA Area({poly|mpoly})
ST_Area() and Area() are synonyms. For more information, see the
description of ST_Area().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlK Ҁ@ �z g "� 6�CENTROID Centroid({poly|mpoly})
ST_Centroid() and Centroid() are synonyms. For more information, see
the description of ST_Centroid().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlK ڀ@ �� h "� 6�EXTERIORRING ExteriorRing(poly)
ST_ExteriorRing() and ExteriorRing() are synonyms. For more
information, see the description of ST_ExteriorRing().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlK �@ �� i "� 6 INTERIORRINGN InteriorRingN(poly, N)
ST_InteriorRingN() and InteriorRingN() are synonyms. For more
information, see the description of ST_InteriorRingN().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlK �@ �� j "� 6NUMINTERIORRINGS NumInteriorRings(poly)
ST_NumInteriorRings() and NumInteriorRings() are synonyms. For more
information, see the description of ST_NumInteriorRings().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlKq�-�@ �� k "� 6%ST_AREA ST_Area({poly|mpoly})
Returns a double-precision number indicating the area of the Polygon or
MultiPolygon argument, as measured in its spatial reference system. For
arguments of dimension 0 or 1, the result is 0. If the argument is an
empty geometry the return value is 0. If the argument is NULL the
return value is NULL.
The result is the sum of the area values of all components for a
geometry collection. If a geometry collection is empty, its area is
returned as 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
mysql> SET @poly =
'Polygon((0 0,0 3,3 0,0 0),(1 1,1 2,2 1,1 1))';
mysql> SELECT ST_Area(ST_GeomFromText(@poly));
+---------------------------------+
| ST_Area(ST_GeomFromText(@poly)) |
+---------------------------------+
| 4 |
+---------------------------------+
mysql> SET @mpoly =
'MultiPolygon(((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1)))';
mysql> SELECT ST_Area(ST_GeomFromText(@mpoly));
+----------------------------------+
| ST_Area(ST_GeomFromText(@mpoly)) |
+----------------------------------+
| 8 |
+----------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html p.o#���� c�XRR x,�� ��E� ;׀ 8� infimum supremumK���@ M l "� 62ST_CENTROID ST_Centroid({poly|mpoly})
Returns the mathematical centroid for the Polygon or MultiPolygon
argument as a Point. The result is not guaranteed to be on the
MultiPolygon. If the argument is NULL or an empty geometry, the return
value is NULL.
This function processes geometry collections by computing the centroid
point for components of highest dimension in the collection. Such
components are extracted and made into a single MultiPolygon,
MultiLineString, or MultiPoint for centroid computation. If the
argument is an empty geometry collection, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
mysql> SET @poly =
ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7,5 5))');
mysql> SELECT ST_GeometryType(@poly),ST_AsText(ST_Centroid(@poly));
+------------------------+--------------------------------------------+
| ST_GeometryType(@poly) | ST_AsText(ST_Centroid(@poly)) |
+------------------------+--------------------------------------------+
| POLYGON | POINT(4.958333333333333 4.958333333333333) |
+------------------------+--------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlK����@ G m "� 6?ST_EXTERIORRING ST_ExteriorRing(poly)
Returns the exterior ring of the Polygon value poly as a LineString. If
the argument is NULL or an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
mysql> SET @poly =
'Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))';
mysql> SELECT ST_AsText(ST_ExteriorRing(ST_GeomFromText(@poly)));
+----------------------------------------------------+
| ST_AsText(ST_ExteriorRing(ST_GeomFromText(@poly))) |
+----------------------------------------------------+
| LINESTRING(0 0,0 3,3 3,3 0,0 0) |
+----------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlK��&�@ � n "� 6LST_INTERIORRINGN ST_InteriorRingN(poly, N)
Returns the N-th interior ring for the Polygon value poly as a
LineString. Rings are numbered beginning with 1. If the argument is
NULL or an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
mysql> SET @poly =
'Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))';
mysql> SELECT ST_AsText(ST_InteriorRingN(ST_GeomFromText(@poly),1));
+-------------------------------------------------------+
| ST_AsText(ST_InteriorRingN(ST_GeomFromText(@poly),1)) |
+-------------------------------------------------------+
| LINESTRING(1 1,1 2,2 2,2 1,1 1) |
+-------------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlK}��@ (5 o "� 6YST_NUMINTERIORRINGS ST_NumInteriorRing(poly), ST_NumInteriorRings(poly)
Returns the number of interior rings in the Polygon value poly. If the
argument is NULL or an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
mysql> SET @poly =
'Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))';
mysql> SELECT ST_NumInteriorRings(ST_GeomFromText(@poly));
+---------------------------------------------+
| ST_NumInteriorRings(ST_GeomFromText(@poly)) |
+---------------------------------------------+
| 1 |
+---------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlV ڀ@ 0� p "� 6fGEOMETRYN GeometryN(gc, N)
ST_GeometryN() and GeometryN() are synonyms. For more information, see
the description of ST_GeometryN().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.htmlV �@ 8� q "� 6sNUMGEOMETRIES NumGeometries(gc)
ST_NumGeometries() and NumGeometries() are synonyms. For more
information, see the description of ST_NumGeometries().
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.htmlV��<�@ @{ r "� 6�ST_GEOMETRYN ST_GeometryN(gc, N)
Returns the N-th geometry in the GeometryCollection value gc.
Geometries are numbered beginning with 1. If any argument is NULL or
the geometry argument is an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html
mysql> SET @gc = 'GeometryCollection(Point(1 1),LineString(2 2, 3 3))';
mysql> SELECT ST_AsText(ST_GeometryN(ST_GeomFromText(@gc),1));
+-------------------------------------------------+
| ST_AsText(ST_GeometryN(ST_GeomFromText(@gc),1)) |
+-------------------------------------------------+
| POINT(1 1) |
+-------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.htmlVU��@ H s "� 6�ST_NUMGEOMETRIES ST_NumGeometries(gc)
Returns the number of geometries in the GeometryCollection value gc. If
the argument is NULL or an empty geometry, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html
mysql> SET @gc = 'GeometryCollection(Point(1 1),LineString(2 2, 3 3))';
mysql> SELECT ST_NumGeometries(ST_GeomFromText(@gc));
+----------------------------------------+
| ST_NumGeometries(ST_GeomFromText(@gc)) |
+----------------------------------------+
| 2 |
+----------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.htmlG �@ P� t "� 6�BUFFER Buffer(g, d [, strategy1 [, strategy2 [, strategy3]]])
ST_Buffer() and Buffer() are synonyms. For more information, see the
description of ST_Buffer().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlG ˀ@ Xp u "� 6�CONVEXHULL ConvexHull(g)
ST_ConvexHull() and ConvexHull() are synonyms. For more information,
see the description of ST_ConvexHull().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlG$��@ `� v "� 6�ST_BUFFER ST_Buffer(g, d [, strategy1 [, strategy2 [, strategy3]]])
Returns a geometry that represents all points whose distance from the
geometry value g is less than or equal to a distance of d, or NULL if
any argument is NULL. The SRID of the geometry argument must be 0
because ST_Buffer() supports only the Cartesian coordinate system. If
any geometry argument is not a syntactically well-formed geometry, an
ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_invalid_data) error occurs.
If the geometry argument is empty, ST_Buffer() returns an empty
geometry.
If the distance is 0, ST_Buffer() returns the geometry argument
unchanged:
mysql> SET @pt = ST_GeomFromText('POINT(0 0)');
mysql> SELECT ST_AsText(ST_Buffer(@pt, 0));
+------------------------------+
| ST_AsText(ST_Buffer(@pt, 0)) |
+------------------------------+
| POINT(0 0) |
+------------------------------+
ST_Buffer() supports negative distances for Polygon and MultiPolygon
values, and for geometry collections containing Polygon or MultiPolygon
values. The result may be an empty geometry. An ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs for ST_Buffer() with a
negative distance for Point, MultiPoint, LineString, and
MultiLineString values, and for geometry collections not containing any
Polygon or MultiPolygon values.
ST_Buffer() permits up to three optional strategy arguments following
the distance argument. Strategies influence buffer computation. These
arguments are byte string values produced by the ST_Buffer_Strategy()
function, to be used for point, join, and end strategies:
o Point strategies apply to Point and MultiPoint geometries. If no
point strategy is specified, the default is
ST_Buffer_Strategy('point_circle', 32).
o Join strategies apply to LineString, MultiLineString, Polygon, and
MultiPolygon geometries. If no join strategy is specified, the
default is ST_Buffer_Strategy('join_round', 32).
o End strategies apply to LineString and MultiLineString geometries. If
no end strategy is specified, the default is
ST_Buffer_Strategy('end_round', 32).
Up to one strategy of each type may be specified, and they may be given
in any order. If multiple strategies of a given type are specified, an
ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
mysql> SET @pt = ST_GeomFromText('POINT(0 0)');
mysql> SET @pt_strategy = ST_Buffer_Strategy('point_square');
mysql> SELECT ST_AsText(ST_Buffer(@pt, 2, @pt_strategy));
+--------------------------------------------+
| ST_AsText(ST_Buffer(@pt, 2, @pt_strategy)) |
+--------------------------------------------+
| POLYGON((-2 -2,2 -2,2 2,-2 2,-2 -2)) |
+--------------------------------------------+
mysql> SET @ls = ST_GeomFromText('LINESTRING(0 0,0 5,5 5)');
mysql> SET @end_strategy = ST_Buffer_Strategy('end_flat');
mysql> SET @join_strategy = ST_Buffer_Strategy('join_round', 10);
mysql> SELECT ST_AsText(ST_Buffer(@ls, 5, @end_strategy, @join_strategy))
+---------------------------------------------------------------+
| ST_AsText(ST_Buffer(@ls, 5, @end_strategy, @join_strategy)) |
+---------------------------------------------------------------+
| POLYGON((5 5,5 10,0 10,-3.5355339059327373 8.535533905932738, |
| -5 5,-5 0,0 0,5 0,5 5)) |
+---------------------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlG g�@ h w "� 6�ST_BUFFER_STRATEGY ST_Buffer_Strategy(strategy [, points_per_circle])
This function returns a strategy byte string for use with ST_Buffer()
to influence buffer computation. If any argument is NULL, the return
value is NULL. If any argument is invalid, an ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs.
Information about strategies is available at Boost.org
(http://www.boost.org).
The first argument must be a string indicating a strategy option:
o For point strategies, permitted values are 'point_circle' and
'point_square'.
o For join strategies, permitted values are 'join_round' and
'join_miter'.
o For end strategies, permitted values are 'end_round' and 'end_flat'.
If the first argument is 'point_circle', 'join_round', 'join_miter', or
'end_round', the points_per_circle argument must be given as a positive
numeric value. The maximum points_per_circle value is the value of the
max_points_in_geometry system variable. If the first argument is
'point_square' or 'end_flat', the points_per_circle argument must not
be given or an ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs.
For examples, see the description of ST_Buffer().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlGk���@ p� x "� 6�ST_CONVEXHULL ST_ConvexHull(g)
Returns a geometry that represents the convex hull of the geometry
value g. If the argument is NULL, the return value is NULL.
This function computes a geometry's convex hull by first checking
whether its vertex points are colinear. The function returns a linear
hull if so, a polygon hull otherwise. This function processes geometry
collections by extracting all vertex points of all components of the
collection, creating a MultiPoint value from them, and computing its
convex hull. If the argument is an empty geometry collection, the
return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
mysql> SET @g = 'MULTIPOINT(5 0,25 0,15 10,15 25)';
mysql> SELECT ST_AsText(ST_ConvexHull(ST_GeomFromText(@g)));
+-----------------------------------------------+
| ST_AsText(ST_ConvexHull(ST_GeomFromText(@g))) |
+-----------------------------------------------+
| POLYGON((5 0,25 0,15 25,5 0)) |
+-----------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlG$���@ x� y "� 6�ST_DIFFERENCE ST_Difference(g1, g2)
Returns a geometry that represents the point set difference of the
geometry values g1 and g2. If any argument is NULL, the return value is
NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
mysql> SET @g1 = Point(1,1), @g2 = Point(2,2);
mysql> SELECT ST_AsText(ST_Difference(@g1, @g2));
+------------------------------------+
| ST_AsText(ST_Difference(@g1, @g2)) |
+------------------------------------+
| POINT(1 1) |
+------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlGu���@ �ǣ z "� 6�ST_INTERSECTION ST_Intersection(g1, g2)
Returns a geometry that represents the point set intersection of the
geometry values g1 and g2. If any argument is NULL, the return value is
NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
mysql> SET @g1 = ST_GeomFromText('LineString(1 1, 3 3)');
mysql> SET @g2 = ST_GeomFromText('LineString(1 3, 3 1)');
mysql> SELECT ST_AsText(ST_Intersection(@g1, @g2));
+--------------------------------------+
| ST_AsText(ST_Intersection(@g1, @g2)) |
+--------------------------------------+
| POINT(2 2) |
+--------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html pw � c�� ���w�� ) #�E� ?|���-�0z ; " infimum supremum@ 0�SESSION_USER @ .�SET DATA TYPE 1@ JSHA1 @ (1$SHA2 @ 0��SIGN v@ 8*4SIN w@ @ JSMALLINT @ H JSOUNDEX �@ P JSOUNDS LIKE �@ X JSPACE �@ ` JSPATIAL COLUMNS 6@ h JSPATIAL INDEXES 7@ p JSQRT x@ x+\SRID O@ �%JSTARTPOINT e@ � JSTRCMP �@ � JSTR_TO_DATE �@ � JST_AREA k@ �!�ST_ASBINARY H@ ��ST_ASTEXT I@ � �ST_CENTROID l@ � �ST_DIMENSION P@ � JST_ENDPOINT _@ � �ST_ENVELOPE Q@ � �ST_EXTERIORRING m@ � JST_GEOMCOLLFROMTEXT '@ �HST_GEOMCOLLFROMWKB 7@ � 8ST_GEOMETRYTYPE R@ � JST_GEOMFROMTEXT (@ � JST_GEOMFROMWKB 8@ �ST_INTERIORRINGN n@ JST_ISCLOSED `@ JST_ISEMPTY S@ ST_ISSIMPLE T@ JST_LENGTH a@( JST_LINEFROMTEXT )@ 0�ST_LINEFROMWKB 9@ 8 JST_MLINEFROMTEXT *@ @ JST_MLINEFROMWKB :@H JST_MPOINTFROMTEXT +@ P JST_MPOINTFROMWKB ;@ X JST_MPOLYFROMTEXT ,@ `�ST_MPOLYFROMWKB <@h�ST_NUMPOINTS b@ p JST_POINTFROMTEXT -@ x JST_POINTFROMWKB =@ � JST_POINTN c@� JST_POLYFROMTEXT .@ �NST_POLYFROMWKB >@ � JST_SRID U@�^ST_STARTPOINT d@� JST_X V@ � JST_Y W@ � JSUBDATE �@ � JSUBSTR �@� JSUBSTRING �@ � JSUBSTRING_INDEX �@ �SUBTIME �@ � JSYSDATE �@� JSYSTEM_USER @ � JTAN y@ � JTEXT +@ JTIME !@ JTIME FUNCTION �@ JTIMEDIFF �@ JTIMESTAMP @ JTIMESTAMP FUNCTION �@( JTIMESTAMPADD �@ 0 JTIMESTAMPDIFF �@ 8 JTIME_FORMAT �@ @ JTIME_TO_SEC �@H JTINYBLOB (@ P JTINYINT @ X�TINYTEXT )@ ` JTO_BASE64 �@h JTO_DAYS �@ p JTO_SECONDS �@ x JTRIM �@ � JTRUE @��TRUNCATE z@ � JUCASE �@ � JUNCOMPRESS @ � JUNCOMPRESSED_LENGTH @��UNHEX �@ �UNIX_TIMESTAMP �@ � JUPDATEXML �@ � JUPPER �@� JUSER @ � JUTC_DATE �@ � JUTC_TIME �@ ��UTC_TIMESTAMP �@�6VALIDATE_PASSWORD_STRENGTH
@ � JVARBINARY '@ �zVARCHAR %@
�VERSION @ JWEEK �@ JWEEKDAY �@ JWEEKOFYEAR �@ ^WEIGHT_STRING �@( JWKT DEFINITION 5@ 0XX X@ 8 JXOR O@ @ JY Y@H JYEAR �@ P JYEAR DATA TYPE "@ X JYEARWEEK �@ ` J^ �@ h J| �@ p ~ �@ x��ST_NUMINTERIORRINGS o@ ��ST_GEOMETRYN r@ ��lST_NUMGEOMETRIES s@ � JST_BUFFER v@ �� ST_BUFFER_STRATEGY w@ ��ST_CONVEXHULL x@ ���ST_DIFFERENCE y@ �PST_INTERSECTION z@ ��ST_SYMDIFFERENCE {@ �\ST_UNION |@��ST_CONTAINS @ ��ST_CROSSES �@ � JST_DISJOINT �@ � ST_DISTANCE �@ ��bST_EQUALS �@ �� ST_INTERSECTS �@ �PST_OVERLAPS �@ ��ST_TOUCHES �@ �ST_WITHIN �@ �dTOUCHES �@ �TWITHIN �@ �ST_GEOHASH �@ (�ST_LATFROMGEOHASH �@ 0�ST_LONGFROMGEOHASH �@ 8�FST_POINTFROMGEOHASH �@ @��ST_ASGEOJSON �@ H�ST_GEOMFROMGEOJSON �@ P� ST_DISTANCE_SPHERE �@ X�DST_ISVALID �@ `��ST_MAKEENVELOPE �@ h�ST_SIMPLIFY �@ p�>ST_VALIDATE �@ x JWAIT_FOR_EXECUTED_GTID_SET �@ ��jWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS �@ � JSTD �@ � JSTDDEV �@ � JSTDDEV_POP �@ �4STDDEV_SAMP �@ ��FSUM �@� JVAR_POP �@ ��VAR_SAMP �@ ��lVARIANCE �@ ��SLEEP �@ � JUUID �@ ��UUID_SHORT �@ ��VALUES �@ ��RTRUNCATE TABLE
@ ��0UNION @ ��0UPDATE @ �`START TRANSACTION @ ҞSET TRANSACTION "@ ��XA #@ �lSET SQL_LOG_BIN '@ �SET GLOBAL SQL_SLAVE_SKIP_COUNTER +@ (��START SLAVE ,@ 0��STOP SLAVE -@ 8��WHILE <@ @�,SHUTDOWN �@ H�DSET PASSWORD L@ P��UNINSTALL PLUGIN U@ X JSET V@ ` JSET CHARACTER SET W@ h��SET CHARSET X@ p��SET NAMES Y@ x JSHOW Z@ � �SHOW BINARY LOGS [@ �:SHOW MASTER LOGS \@ � JSHOW BINLOG EVENTS ]@� JSHOW CHARACTER SET ^@ � JSHOW COLLATION _@ � �SHOW COLUMNS `@ ��SHOW FIELDS a@ � �SHOW CREATE DATABASE b@ �(SHOW CREATE SCHEMA c@� JSHOW CREATE EVENT d@ � JSHOW CREATE FUNCTION e@ �"SHOW CREATE PROCEDURE f@� JSHOW CREATE TABLE g@ � JSHOW CREATE TRIGGER h@ � JSHOW CREATE USER i@ � JSHOW CREATE VIEW j@ �SHOW DATABASES k@ ~SHOW SCHEMAS l@ JSHOW ENGINE m@ JSHOW ENGINES n@ JSHOW ERRORS o@(��SHOW EVENTS p@ 0 JSHOW FUNCTION CODE q@ 8 JSHOW FUNCTION STATUS r@@ JSHOW GRANTS s@ H�SHOW INDEX t@ P JSHOW MASTER STATUS u@X JSHOW OPEN TABLES v@ ` JSHOW PLUGINS w@ h JSHOW PRIVILEGES x@ p JSHOW PROCEDURE CODE y@x JSHOW PROCEDURE STATUS z@ � JSHOW PROCESSLIST {@ � JSHOW PROFILE |@ � JSHOW PROFILES }@���SHOW RELAYLOG EVENTS ~@ � JSHOW SLAVE HOSTS @ � JSHOW SLAVE STATUS �@� JSHOW STATUS �@ � JSHOW TABLE STATUS �@ � JSHOW TABLES �@ � JSHOW TRIGGERS �@ � JSHOW VARIABLES �@ ��BSHOW WARNINGS � p D �+F��|T,���d<� � �
� tL$�"����� p�=�<�;�:�9�8�7j6B5d3�\/R c�w�� #�*;� �E� ;1� 9 infimum supremumG��Ձ@ { "� 6�ST_SYMDIFFERENCE ST_SymDifference(g1, g2)
Returns a geometry that represents the point set symmetric difference
of the geometry values g1 and g2, which is defined as:
g1 symdifference g2 := (g1 union g2) difference (g1 intersection g2)
Or, in function call notation:
ST_SymDifference(g1, g2) = ST_Difference(ST_Union(g1, g2), ST_Intersection(g1, g2))
If any argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
mysql> SET @g1 = ST_GeomFromText('MULTIPOINT(5 0,15 10,15 25)');
mysql> SET @g2 = ST_GeomFromText('MULTIPOINT(1 1,15 10,15 25)');
mysql> SELECT ST_AsText(ST_SymDifference(@g1, @g2));
+---------------------------------------+
| ST_AsText(ST_SymDifference(@g1, @g2)) |
+---------------------------------------+
| MULTIPOINT((1 1),(5 0)) |
+---------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlGn��@ � | "� 6ST_UNION ST_Union(g1, g2)
Returns a geometry that represents the point set union of the geometry
values g1 and g2. If any argument is NULL, the return value is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
mysql> SET @g1 = ST_GeomFromText('LineString(1 1, 3 3)');
mysql> SET @g2 = ST_GeomFromText('LineString(1 3, 3 1)');
mysql> SELECT ST_AsText(ST_Union(@g1, @g2));
+--------------------------------------+
| ST_AsText(ST_Union(@g1, @g2)) |
+--------------------------------------+
| MULTILINESTRING((1 1,3 3),(1 3,3 1)) |
+--------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlU Ҁ@ � } "� 6CROSSES Crosses(g1, g2)
ST_Crosses() and Crosses() are synonyms. For more information, see the
description of ST_Crosses().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU ր@ (� ~ "� 6 DISTANCE Distance(g1, g2)
ST_Distance() and Distance() are synonyms. For more information, see
the description of ST_Distance().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU �@ 0� "� 6)ST_CONTAINS ST_Contains(g1, g2)
Returns 1 or 0 to indicate whether g1 completely contains g2. This
tests the opposite relationship as ST_Within().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU �@ 8� � "� 66ST_CROSSES ST_Crosses(g1, g2)
The term spatially crosses denotes a spatial relation between two given
geometries that has the following properties:
o The two geometries intersect.
o Their intersection results in a geometry that has a dimension that is
one less than the maximum dimension of the two given geometries.
o Their intersection is not equal to either of the two given
geometries.
This function returns 1 or 0 to indicate whether g1 spatially crosses
g2. If g1 is a Polygon or a MultiPolygon, or if g2 is a Point or a
MultiPoint, the return value is NULL.
This function returns 0 if called with an inapplicable geometry
argument type combination. For example, it returns 0 if the first
argument is a Polygon or MultiPolygon and/or the second argument is a
Point or MultiPoint.
Returns 1 if g1 spatially crosses g2. Returns NULL if g1 is a Polygon
or a MultiPolygon, or if g2 is a Point or a MultiPoint. Otherwise,
returns 0.
This function returns 0 if called with an inapplicable geometry
argument type combination. For example, it returns 0 if the first
argument is a Polygon or MultiPolygon and/or the second argument is a
Point or MultiPoint.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU ̀@ @ � "� 6CST_DISJOINT ST_Disjoint(g1, g2)
Returns 1 or 0 to indicate whether g1 is spatially disjoint from (does
not intersect) g2.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU�Q�@ H� � "� 6PST_DISTANCE ST_Distance(g1, g2)
Returns the distance between g1 and g2. If either argument is NULL or
an empty geometry, the return value is NULL.
This function processes geometry collections by returning the shortest
distance among all combinations of the components of the two geometry
arguments.
If an intermediate or final result produces NaN or a negative number,
an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_invalid_data) error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
mysql> SET @g1 = Point(1,1);
mysql> SET @g2 = Point(2,2);
mysql> SELECT ST_Distance(@g1, @g2);
+-----------------------+
| ST_Distance(@g1, @g2) |
+-----------------------+
| 1.4142135623730951 |
+-----------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlUM���@ P� � "� 6]ST_EQUALS ST_Equals(g1, g2)
Returns 1 or 0 to indicate whether g1 is spatially equal to g2.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
mysql> SET @g1 = Point(1,1), @g2 = Point(2,2);
mysql> SELECT ST_Equals(@g1, @g1), ST_Equals(@g1, @g2);
+---------------------+---------------------+
| ST_Equals(@g1, @g1) | ST_Equals(@g1, @g2) |
+---------------------+---------------------+
| 1 | 0 |
+---------------------+---------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU ��@ Xe � "� 6jST_INTERSECTS ST_Intersects(g1, g2)
Returns 1 or 0 to indicate whether g1 spatially intersects g2.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU )�@ `� � "� 6wST_OVERLAPS ST_Overlaps(g1, g2)
Two geometries spatially overlap if they intersect and their
intersection results in a geometry of the same dimension but not equal
to either of the given geometries.
This function returns 1 or 0 to indicate whether g1 spatially overlaps
g2.
This function returns 0 if called with an inapplicable geometry
argument type combination. For example, it returns 0 if called with
geometries of different dimensions or any argument is a Point.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU �@ h� � "� 6�ST_TOUCHES ST_Touches(g1, g2)
Two geometries spatially touch if their interiors do not intersect, but
the boundary of one of the geometries intersects either the boundary or
the interior of the other.
This function returns 1 or 0 to indicate whether g1 spatially touches
g2.
This function returns 0 if called with an inapplicable geometry
argument type combination. For example, it returns 0 if either of the
arguments is a Point or MultiPoint.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU �@ p� � "� 6�ST_WITHIN ST_Within(g1, g2)
Returns 1 or 0 to indicate whether g1 is spatially within g2. This
tests the opposite relationship as ST_Contains().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlU Ҁ@ x� � "� 6�TOUCHES Touches(g1, g2)
ST_Touches() and Touches() are synonyms. For more information, see the
description of ST_Touches().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlK���@ �O � "� 6�MBRCONTAINS !MBRContains(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1
contains the minimum bounding rectangle of g2. This tests the opposite
relationship as MBRWithin().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
mysql> SET @g1 = ST_GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');
mysql> SET @g2 = ST_GeomFromText('Point(1 1)');
mysql> SELECT MBRContains(@g1,@g2), MBRWithin(@g2,@g1);
+----------------------+--------------------+
| MBRContains(@g1,@g2) | MBRWithin(@g2,@g1) |
+----------------------+--------------------+
| 1 | 1 |
+----------------------+--------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK����@ �
� "� 6�MBRCOVEREDBY !MBRCoveredBy(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1
is covered by the minimum bounding rectangle of g2. This tests the
opposite relationship as MBRCovers().
MBRCoveredBy() handles its arguments as follows:
o If either argument is NULL or an empty geometry, the return value is
NULL.
o If either argument is not a syntactically well-formed geometry byte
string, an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference
.html#error_er_gis_invalid_data) error occurs.
o Otherwise, the return value is non-NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
mysql> SET @g1 = ST_GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');
mysql> SET @g2 = ST_GeomFromText('Point(1 1)');
mysql> SELECT MBRCovers(@g1,@g2), MBRCoveredby(@g1,@g2);
+--------------------+-----------------------+
| MBRCovers(@g1,@g2) | MBRCoveredby(@g1,@g2) |
+--------------------+-----------------------+
| 1 | 0 |
+--------------------+-----------------------+
mysql> SELECT MBRCovers(@g2,@g1), MBRCoveredby(@g2,@g1);
+--------------------+-----------------------+
| MBRCovers(@g2,@g1) | MBRCoveredby(@g2,@g1) |
+--------------------+-----------------------+
| 0 | 1 |
+--------------------+-----------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ӂ@ �{ � "� 6�MBRCOVERS !MBRCovers(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1
covers the minimum bounding rectangle of g2. This tests the opposite
relationship as MBRCoveredBy(). See the description of MBRCoveredBy()
for examples.
MBRCovers() handles its arguments as follows:
o If either argument is NULL or an empty geometry, the return value is
NULL.
o If either argument is not a syntactically well-formed geometry byte
string, an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference
.html#error_er_gis_invalid_data) error occurs.
o Otherwise, the return value is non-NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK �@ �� � "� 6�MBRDISJOINT !MBRDisjoint(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangles of
the two geometries g1 and g2 are disjoint (do not intersect).
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ր@ �~ � "� 6�MBREQUAL !MBREqual(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangles of
the two geometries g1 and g2 are the same.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ׀@ � � "� 6�MBREQUALS !MBREquals(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangles of
the two geometries g1 and g2 are the same.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK @ �� � "� 6�MBRINTERSECTS !MBRIntersects(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangles of
the two geometries g1 and g2 intersect.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ��@ �2 � "� 6MBROVERLAPS !MBROverlaps(g1, g2)
Two geometries spatially overlap if they intersect and their
intersection results in a geometry of the same dimension but not equal
to either of the given geometries.
This function returns 1 or 0 to indicate whether the minimum bounding
rectangles of the two geometries g1 and g2 overlap.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ��@ ��h � "� 6MBRTOUCHES !MBRTouches(g1, g2)
Two geometries spatially touch if their interiors do not intersect, but
the boundary of one of the geometries intersects either the boundary or
the interior of the other.
This function returns 1 or 0 to indicate whether the minimum bounding
rectangles of the two geometries g1 and g2 touch.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html p'= : c*;� �$?�� F�E� 95� 25 infimum supremumK���@ W � "� 6 MBRWITHIN !MBRWithin(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1
is within the minimum bounding rectangle of g2. This tests the opposite
relationship as MBRContains().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
mysql> SET @g1 = ST_GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');
mysql> SET @g2 = ST_GeomFromText('Polygon((0 0,0 5,5 5,5 0,0 0))');
mysql> SELECT MBRWithin(@g1,@g2), MBRWithin(@g2,@g1);
+--------------------+--------------------+
| MBRWithin(@g1,@g2) | MBRWithin(@g2,@g1) |
+--------------------+--------------------+
| 1 | 0 |
+--------------------+--------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ̀@ t � "� 6-CONTAINS !Contains(g1, g2)
MBRContains() and Contains() are synonyms. For more information, see
the description of MBRContains().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ̀@ t � "� 6:DISJOINT !Disjoint(g1, g2)
MBRDisjoint() and Disjoint() are synonyms. For more information, see
the description of MBRDisjoint().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK Ā@ (l � "� 6GEQUALS !Equals(g1, g2)
MBREquals() and Equals() are synonyms. For more information, see the
description of MBREquals().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK Ԁ@ 0| � "� 6TINTERSECTS !Intersects(g1, g2)
MBRIntersects() and Intersects() are synonyms. For more information,
see the description of MBRIntersects().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK ̀@ 8t � "� 6aOVERLAPS !Overlaps(g1, g2)
MBROverlaps() and Overlaps() are synonyms. For more information, see
the description of MBROverlaps().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlK Ā@ @m � "� 6nWITHIN !Within(g1, g2)
MBRWithin() and Within() are synonyms. For more information, see the
description of MBRWithin().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
https://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlF<���@ H� � "� 6{ST_GEOHASH !ST_GeoHash(longitude, latitude, max_length), ST_GeoHash(point,
max_length)
Returns a geohash string in the connection character set and collation.
If any argument is NULL, the return value is NULL. If any argument is
invalid, an error occurs.
For the first syntax, the longitude must be a number in the range
[−180, 180], and the latitude must be a number in the range [−90,
90]. For the second syntax, a POINT value is required, where the X and
Y coordinates are in the valid ranges for longitude and latitude,
respectively.
The resulting string is no longer than max_length characters, which has
an upper limit of 100. The string might be shorter than max_length
characters because the algorithm that creates the geohash value
continues until it has created a string that is either an exact
representation of the location or max_length characters, whichever
comes first.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.html
mysql> SELECT ST_GeoHash(180,0,10), ST_GeoHash(-180,-90,15);
+----------------------+-------------------------+
| ST_GeoHash(180,0,10) | ST_GeoHash(-180,-90,15) |
+----------------------+-------------------------+
| xbpbpbpbpb | 000000000000000 |
+----------------------+-------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.htmlF�]�@ P � "� 6�ST_LATFROMGEOHASH !ST_LatFromGeoHash(geohash_str)
Returns the latitude from a geohash string value, as a DOUBLE value in
the range [−90, 90].
If the argument is NULL, the return value is NULL. If the argument is
invalid, an error occurs.
The ST_LatFromGeoHash() decoding function reads no more than 433
characters from the geohash_str argument. That represents the upper
limit on information in the internal representation of coordinate
values. Characters past the 433rd are ignored, even if they are
otherwise illegal and produce an error.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.html
mysql> SELECT ST_LatFromGeoHash(ST_GeoHash(45,-20,10));
+------------------------------------------+
| ST_LatFromGeoHash(ST_GeoHash(45,-20,10)) |
+------------------------------------------+
| -20 |
+------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.htmlF �߁@ X� � "� 6�ST_LONGFROMGEOHASH !ST_LongFromGeoHash(geohash_str)
Returns the longitude from a geohash string value, as a DOUBLE value in
the range [−180, 180].
If the argument is NULL, the return value is NULL. If the argument is
invalid, an error occurs.
The remarks in the description of ST_LatFromGeoHash() regarding the
maximum number of characters processed from the geohash_str argument
also apply to ST_LongFromGeoHash().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.html
mysql> SELECT ST_LongFromGeoHash(ST_GeoHash(45,-20,10));
+-------------------------------------------+
| ST_LongFromGeoHash(ST_GeoHash(45,-20,10)) |
+-------------------------------------------+
| 45 |
+-------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.htmlF/���@ `q � "� 6�ST_POINTFROMGEOHASH !ST_PointFromGeoHash(geohash_str, srid)
Returns a POINT value containing the decoded geohash value, given a
geohash string value.
The X and Y coordinates of the point are the longitude in the range
[−180, 180] and the latitude in the range [−90, 90], respectively.
If any argument is NULL, the return value is NULL. If any argument is
invalid, an error occurs.
The srid argument is an unsigned 32-bit integer.
The remarks in the description of ST_LatFromGeoHash() regarding the
maximum number of characters processed from the geohash_str argument
also apply to ST_PointFromGeoHash().
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.html
mysql> SET @gh = ST_GeoHash(45,-20,10);
mysql> SELECT ST_AsText(ST_PointFromGeoHash(@gh,0));
+---------------------------------------+
| ST_AsText(ST_PointFromGeoHash(@gh,0)) |
+---------------------------------------+
| POINT(45 -20) |
+---------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.htmlF��Z�@ h� � "� 6�ST_ASGEOJSON !ST_AsGeoJSON(g [, max_dec_digits [, options]])
Generates a GeoJSON object from the geometry g. The object string has
the connection character set and collation.
If any argument is NULL, the return value is NULL. If any non-NULL
argument is invalid, an error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-geojson-functions.html
mysql> SELECT ST_AsGeoJSON(ST_GeomFromText('POINT(11.11111 12.22222)'),2);
+-------------------------------------------------------------+
| ST_AsGeoJSON(ST_GeomFromText('POINT(11.11111 12.22222)'),2) |
+-------------------------------------------------------------+
| {"type": "Point", "coordinates": [11.11, 12.22]} |
+-------------------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-geojson-functions.htmlFG�0�@ p � "� 6�ST_GEOMFROMGEOJSON !ST_GeomFromGeoJSON(str [, options [, srid]])
Parses a string str representing a GeoJSON object and returns a
geometry.
If any argument is NULL, the return value is NULL. If any non-NULL
argument is invalid, an error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-geojson-functions.html
mysql> SET @json = '{ "type": "Point", "coordinates": [102.0, 0.0]}';
mysql> SELECT ST_AsText(ST_GeomFromGeoJSON(@json));
+--------------------------------------+
| ST_AsText(ST_GeomFromGeoJSON(@json)) |
+--------------------------------------+
| POINT(102 0) |
+--------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-geojson-functions.htmlJA� �@ x � "� 6�ST_DISTANCE_SPHERE !ST_Distance_Sphere(g1, g2 [, radius])
Returns the mimimum spherical distance between two points and/or
multipoints on a sphere, in meters, or NULL if any geometry argument is
NULL or empty.
Calculations use a spherical earth and a configurable radius. The
optional radius argument should be given in meters. If omitted, the
default radius is 6,370,986 meters. An ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs if the radius argument is
present but not positive.
The geometry arguments should consist of points that specify
(longitude, latitude) coordinate values:
o Longitude and latitude are the first and second coordinates of the
point, respectively.
o Both coordinates are in degrees.
o Longitude values must be in the range (-180, 180]. Positive values
are east of the prime meridian.
o Latitude values must be in the range [-90, 90]. Positive values are
north of the equator.
Supported argument combinations are (Point, Point), (Point,
MultiPoint), and (MultiPoint, Point). An ER_GIS_UNSUPPORTED_ARGUMENT
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_unsupported_argument) error occurs for other
combinations.
If any geometry argument is not a syntactically well-formed geometry
byte string, an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_invalid_data) error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html
mysql> SET @pt1 = ST_GeomFromText('POINT(0 0)');
mysql> SET @pt2 = ST_GeomFromText('POINT(180 0)');
mysql> SELECT ST_Distance_Sphere(@pt1, @pt2);
+--------------------------------+
| ST_Distance_Sphere(@pt1, @pt2) |
+--------------------------------+
| 20015042.813723423 |
+--------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.htmlJ����@ �4 � "� 6�ST_ISVALID !ST_IsValid(g)
Returns 1 if the argument is syntactically well-formed and is
geometrically valid, 0 if the argument is not syntactically well-formed
or is not geometrically valid. If the argument is NULL, the return
value is NULL. Geometry validity is defined by the OGC specification.
The only valid empty geometry is represented in the form of an empty
geometry collection value. ST_IsValid() returns 1 in this case.
ST_IsValid() works only for the Cartesian coordinate system and
requires a geometry argument with an SRID of 0. An ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs otherwise.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html
mysql> SET @ls1 = ST_GeomFromText('LINESTRING(0 0,-0.00 0,0.0 0)');
mysql> SET @ls2 = ST_GeomFromText('LINESTRING(0 0, 1 1)');
mysql> SELECT ST_IsValid(@ls1);
+------------------+
| ST_IsValid(@ls1) |
+------------------+
| 0 |
+------------------+
mysql> SELECT ST_IsValid(@ls2);
+------------------+
| ST_IsValid(@ls2) |
+------------------+
| 1 |
+------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.htmlJo��@ ��; � "� 6�ST_MAKEENVELOPE !ST_MakeEnvelope(pt1, pt2)
Returns the rectangle that forms the envelope around two points, as a
Point, LineString, or Polygon. If any argument is NULL, the return
value is NULL.
Calculations are done using the Cartesian coordinate system rather than
on a sphere, spheroid, or on earth.
Given two points pt1 and pt2, ST_MakeEnvelope() creates the result
geometry on an abstract plane like this:
o If pt1 and pt2 are equal, the result is the point pt1.
o Otherwise, if (pt1, pt2) is a vertical or horizontal line segment,
the result is the line segment (pt1, pt2).
o Otherwise, the result is a polygon using pt1 and pt2 as diagonal
points.
The result geometry has an SRID of 0.
ST_MakeEnvelope() requires Point geometry arguments with an SRID of 0.
An ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs otherwise.
If any argument is not a syntactically well-formed geometry byte
string, or if any coordinate value of the two points is infinite or
NaN, an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_invalid_data) error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html
mysql> SET @pt1 = ST_GeomFromText('POINT(0 0)');
mysql> SET @pt2 = ST_GeomFromText('POINT(1 1)');
mysql> SELECT ST_AsText(ST_MakeEnvelope(@pt1, @pt2));
+----------------------------------------+
| ST_AsText(ST_MakeEnvelope(@pt1, @pt2)) |
+----------------------------------------+
| POLYGON((0 0,1 0,1 1,0 1,0 0)) |
+----------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html p W �� c$?�� F���~ {4E� 5��
.e infimum supremumJ�r�@ , � "� 6�ST_SIMPLIFY !ST_Simplify(g, max_distance)
Simplifies a geometry using the Douglas-Peucker algorithm and returns a
simplified value of the same type. If any argument is NULL, the return
value is NULL.
The geometry may be any geometry type, although the Douglas-Peucker
algorithm may not actually process every type. A geometry collection is
processed by giving its components one by one to the simplification
algorithm, and the returned geometries are put into a geometry
collection as result.
The max_distance argument is the distance (in units of the input
coordinates) of a vertex to other segments to be removed. Vertices
within this distance of the simplified linestring are removed. If the
max_distance argument is not positive, or is NaN, an ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs.
According to Boost.Geometry, geometries might become invalid as a
result of the simplification process, and the process might create
self-intersections. To check the validity of the result, pass it to
ST_IsValid().
If the geometry argument is not a syntactically well-formed geometry
byte string, an ER_GIS_INVALID_DATA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_gis_invalid_data) error occurs.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html
mysql> SET @g = ST_GeomFromText('LINESTRING(0 0,0 1,1 1,1 2,2 2,2 3,3 3)');
mysql> SELECT ST_AsText(ST_Simplify(@g, 0.5));
+---------------------------------+
| ST_AsText(ST_Simplify(@g, 0.5)) |
+---------------------------------+
| LINESTRING(0 0,0 1,1 1,2 3,3 3) |
+---------------------------------+
mysql> SELECT ST_AsText(ST_Simplify(@g, 1.0));
+---------------------------------+
| ST_AsText(ST_Simplify(@g, 1.0)) |
+---------------------------------+
| LINESTRING(0 0,3 3) |
+---------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.htmlJ���@ > � "� 6�ST_VALIDATE !ST_Validate(g)
Validates a geometry according to the OGC specification. A geometry can
be syntactically well-formed (WKB value plus SRID) but geometrically
invalid. For example, this polygon is geometrically invalid: POLYGON((0
0, 0 0, 0 0, 0 0, 0 0))
ST_Validate() returns the geometry if it is syntactically well-formed
and is geometrically valid, NULL if the argument is not syntactically
well-formed or is not geometrically valid or is NULL.
ST_Validate() can be used to filter out invalid geometry data, although
at a cost. For applications that require more precise results not
tainted by invalid data, this penalty may be worthwhile.
If the geometry argument is valid, it is returned as is, except that if
an input Polygon or MultiPolygon has clockwise rings, those rings are
reversed before checking for validity. If the geometry is valid, the
value with the reversed rings is returned.
The only valid empty geometry is represented in the form of an empty
geometry collection value. ST_Validate() returns it directly without
further checks in this case.
ST_Validate() works only for the Cartesian coordinate system and
requires a geometry argument with an SRID of 0. An ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments) error occurs otherwise.
URL: https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html
mysql> SET @ls1 = ST_GeomFromText('LINESTRING(0 0)');
mysql> SET @ls2 = ST_GeomFromText('LINESTRING(0 0, 1 1)');
mysql> SELECT ST_AsText(ST_Validate(@ls1));
+------------------------------+
| ST_AsText(ST_Validate(@ls1)) |
+------------------------------+
| NULL |
+------------------------------+
mysql> SELECT ST_AsText(ST_Validate(@ls2));
+------------------------------+
| ST_AsText(ST_Validate(@ls2)) |
+------------------------------+
| LINESTRING(0 0,1 1) |
+------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.htmlD+�Ѐ@ � � "� 6
JSON_ARRAY !Syntax:
JSON_ARRAY([val[, val] ...])
Evaluates a (possibly empty) list of values and returns a JSON array
containing those values.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.html
mysql> SELECT JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME());
+---------------------------------------------+
| JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME()) |
+---------------------------------------------+
| [1, "abc", null, true, "11:30:24.000000"] |
+---------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.htmlD�/�@ (� � "� 6JSON_OBJECT !Syntax:
JSON_OBJECT([key, val[, key, val] ...])
Evaluates a (possibly empty) list of key-value pairs and returns a JSON
object containing those pairs. An error occurs if any key name is NULL
or the number of arguments is odd.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.html
mysql> SELECT JSON_OBJECT('id', 87, 'name', 'carrot');
+-----------------------------------------+
| JSON_OBJECT('id', 87, 'name', 'carrot') |
+-----------------------------------------+
| {"id": 87, "name": "carrot"} |
+-----------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.htmlDсw�@ 0� � "� 6$JSON_QUOTE !Syntax:
JSON_QUOTE(string)
Quotes a string as a JSON value by wrapping it with double quote
characters and escaping interior quote and other characters, then
returning the result as a utf8mb4 string. Returns NULL if the argument
is NULL.
This function is typically used to produce a valid JSON string literal
for inclusion within a JSON document.
Certain special characters are escaped with backslashes per the escape
sequences shown in
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
#json-unquote-character-escape-sequences.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.html
mysql> SELECT JSON_QUOTE('null'), JSON_QUOTE('"null"');
+--------------------+----------------------+
| JSON_QUOTE('null') | JSON_QUOTE('"null"') |
+--------------------+----------------------+
| "null" | "\"null\"" |
+--------------------+----------------------+
mysql> SELECT JSON_QUOTE('[1, 2, 3]');
+-------------------------+
| JSON_QUOTE('[1, 2, 3]') |
+-------------------------+
| "[1, 2, 3]" |
+-------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.htmlBÃ^�@ 8
� � "� 61JSON_CONTAINS !Syntax:
JSON_CONTAINS(target, candidate[, path])
Indicates by returning 1 or 0 whether a given candidate JSON document
is contained within a target JSON document, or---if a path argument was
supplied---whether the candidate is found at a specific path within the
target. Returns NULL if any argument is NULL, or if the path argument
does not identify a section of the target document. An error occurs if
target or candidate is not a valid JSON document, or if the path
argument is not a valid path expression or contains a * or ** wildcard.
To check only whether any data exists at the path, use
JSON_CONTAINS_PATH() instead.
The following rules define containment:
o A candidate scalar is contained in a target scalar if and only if
they are comparable and are equal. Two scalar values are comparable
if they have the same JSON_TYPE() types, with the exception that
values of types INTEGER and DECIMAL are also comparable to each
other.
o A candidate array is contained in a target array if and only if every
element in the candidate is contained in some element of the target.
o A candidate nonarray is contained in a target array if and only if
the candidate is contained in some element of the target.
o A candidate object is contained in a target object if and only if for
each key in the candidate there is a key with the same name in the
target and the value associated with the candidate key is contained
in the value associated with the target key.
Otherwise, the candidate value is not contained in the target document.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html
mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.a');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.a') |
+-------------------------------+
| 1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.b');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.b') |
+-------------------------------+
| 0 |
+-------------------------------+
mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.a');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.a') |
+-------------------------------+
| 0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.c');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.c') |
+-------------------------------+
| 1 |
+-------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.htmlB�� �@ @L � "� 6>JSON_CONTAINS_PATH !Syntax:
JSON_CONTAINS_PATH(json_doc, one_or_all, path[, path] ...)
Returns 0 or 1 to indicate whether a JSON document contains data at a
given path or paths. Returns NULL if any argument is NULL. An error
occurs if the json_doc argument is not a valid JSON document, any path
argument is not a valid path expression, or one_or_all is not 'one' or
'all'.
To check for a specific value at a path, use JSON_CONTAINS() instead.
The return value is 0 if no specified path exists within the document.
Otherwise, the return value depends on the one_or_all argument:
o 'one': 1 if at least one path exists within the document, 0
otherwise.
o 'all': 1 if all paths exist within the document, 0 otherwise.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html
mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH(@j, 'one', '$.a', '$.e');
+---------------------------------------------+
| JSON_CONTAINS_PATH(@j, 'one', '$.a', '$.e') |
+---------------------------------------------+
| 1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH(@j, 'all', '$.a', '$.e');
+---------------------------------------------+
| JSON_CONTAINS_PATH(@j, 'all', '$.a', '$.e') |
+---------------------------------------------+
| 0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH(@j, 'one', '$.c.d');
+----------------------------------------+
| JSON_CONTAINS_PATH(@j, 'one', '$.c.d') |
+----------------------------------------+
| 1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH(@j, 'one', '$.a.d');
+----------------------------------------+
| JSON_CONTAINS_PATH(@j, 'one', '$.a.d') |
+----------------------------------------+
| 0 |
+----------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.htmlB���@ H� � "� 6KJSON_EXTRACT !Syntax:
JSON_EXTRACT(json_doc, path[, path] ...)
Returns data from a JSON document, selected from the parts of the
document matched by the path arguments. Returns NULL if any argument is
NULL or no paths locate a value in the document. An error occurs if the
json_doc argument is not a valid JSON document or any path argument is
not a valid path expression.
The return value consists of all values matched by the path arguments.
If it is possible that those arguments could return multiple values,
the matched values are autowrapped as an array, in the order
corresponding to the paths that produced them. Otherwise, the return
value is the single matched value.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html
mysql> SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]');
+--------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]') |
+--------------------------------------------+
| 20 |
+--------------------------------------------+
mysql> SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]', '$[0]');
+----------------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]', '$[0]') |
+----------------------------------------------------+
| [20, 10] |
+----------------------------------------------------+
mysql> SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[2][*]');
+-----------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[2][*]') |
+-----------------------------------------------+
| [30, 40] |
+-----------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html p� c��~ {4�U.� ��E� :Ҁ � infimum supremumB��́@ � � "� 6X-> !Syntax:
column->path
In MySQL 5.7.9 and later, the -> operator serves as an alias for the
JSON_EXTRACT() function when used with two arguments, a column
identifier on the left and a JSON path (a string literal) on the right
that is evaluated against the JSON document (the column value). You can
use such expressions in place of column references wherever they occur
in SQL statements.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html
mysql> SELECT c, JSON_EXTRACT(c, "$.id"), g
> FROM jemp
> WHERE JSON_EXTRACT(c, "$.id") > 1
> ORDER BY JSON_EXTRACT(c, "$.name");
+-------------------------------+-----------+------+
| c | c->"$.id" | g |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3" | 3 |
| {"id": "4", "name": "Betty"} | "4" | 4 |
| {"id": "2", "name": "Wilma"} | "2" | 2 |
+-------------------------------+-----------+------+
3 rows in set (0.00 sec)
mysql> SELECT c, c->"$.id", g
> FROM jemp
> WHERE c->"$.id" > 1
> ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c | c->"$.id" | g |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3" | 3 |
| {"id": "4", "name": "Betty"} | "4" | 4 |
| {"id": "2", "name": "Wilma"} | "2" | 2 |
+-------------------------------+-----------+------+
3 rows in set (0.00 sec)
mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected (0.68 sec)
Records: 0 Duplicates: 0 Warnings: 0
mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected (0.04 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> SELECT c, c->"$.id", g, n
> FROM jemp
> WHERE JSON_EXTRACT(c, "$.id") > 1
> ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c | c->"$.id" | g | n |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3" | 3 | NULL |
| {"id": "4", "name": "Betty"} | "4" | 4 | 1 |
| {"id": "2", "name": "Wilma"} | "2" | 2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set (0.00 sec)
mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected (0.04 sec)
mysql> SELECT c, c->"$.id", g, n
> FROM jemp
> WHERE JSON_EXTRACT(c, "$.id") > 1
> ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c | c->"$.id" | g | n |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3" | 3 | NULL |
| {"id": "2", "name": "Wilma"} | "2" | 2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.htmlB���@ | � "� 6e->> !Syntax:
column->>path
This is an improved, unquoting extraction operator available in MySQL
5.7.13 and later. Whereas the -> operator simply extracts a value, the
->> operator in addition unquotes the extracted result. In other words,
given a JSON column value column and a path expression path (a string
literal), the following three expressions return the same value:
o JSON_UNQUOTE( JSON_EXTRACT(column, path) )
o JSON_UNQUOTE(column -> path)
o column->>path
The ->> operator can be used wherever JSON_UNQUOTE(JSON_EXTRACT())
would be allowed. This includes (but is not limited to) SELECT lists,
WHERE and HAVING clauses, and ORDER BY and GROUP BY clauses.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html
mysql> SELECT * FROM jemp WHERE g > 2;
+-------------------------------+------+
| c | g |
+-------------------------------+------+
| {"id": "3", "name": "Barney"} | 3 |
| {"id": "4", "name": "Betty"} | 4 |
+-------------------------------+------+
2 rows in set (0.01 sec)
mysql> SELECT c->'$.name' AS name
-> FROM jemp WHERE g > 2;
+----------+
| name |
+----------+
| "Barney" |
| "Betty" |
+----------+
2 rows in set (0.00 sec)
mysql> SELECT JSON_UNQUOTE(c->'$.name') AS name
-> FROM jemp WHERE g > 2;
+--------+
| name |
+--------+
| Barney |
| Betty |
+--------+
2 rows in set (0.00 sec)
mysql> SELECT c->>'$.name' AS name
-> FROM jemp WHERE g > 2;
+--------+
| name |
+--------+
| Barney |
| Betty |
+--------+
2 rows in set (0.00 sec)
mysql> CREATE TABLE tj10 (a JSON, b INT);
Query OK, 0 rows affected (0.26 sec)
mysql> INSERT INTO tj10 VALUES
-> ('[3,10,5,"x",44]', 33),
-> ('[3,10,5,17,[22,"y",66]]', 0);
Query OK, 2 rows affected (0.04 sec)
Records: 2 Duplicates: 0 Warnings: 0
mysql> SELECT a->"$[3]", a->"$[4][1]" FROM tj10;
+-----------+--------------+
| a->"$[3]" | a->"$[4][1]" |
+-----------+--------------+
| "x" | NULL |
| 17 | "y" |
+-----------+--------------+
2 rows in set (0.00 sec)
mysql> SELECT a->>"$[3]", a->>"$[4][1]" FROM tj10;
+------------+---------------+
| a->>"$[3]" | a->>"$[4][1]" |
+------------+---------------+
| x | NULL |
| 17 | y |
+------------+---------------+
2 rows in set (0.00 sec)
mysql> EXPLAIN SELECT c->>'$.name' AS name
-> FROM jemp WHERE g > 2\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: jemp
partitions: NULL
type: range
possible_keys: i
key: i
key_len: 5
ref: NULL
rows: 2
filtered: 100.00
Extra: Using where
1 row in set, 1 warning (0.00 sec)
mysql> SHOW WARNINGS\G
*************************** 1. row ***************************
Level: Note
Code: 1003
Message: /* select#1 */ select
json_unquote(json_extract(`jtest`.`jemp`.`c`,'$.name')) AS `name` from
`jtest`.`jemp` where (`jtest`.`jemp`.`g` > 2)
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.htmlB8�ł@ � � "� 6rJSON_KEYS !Syntax:
JSON_KEYS(json_doc[, path])
Returns the keys from the top-level value of a JSON object as a JSON
array, or, if a path argument is given, the top-level keys from the
selected path. Returns NULL if any argument is NULL, the json_doc
argument is not an object, or path, if given, does not locate an
object. An error occurs if the json_doc argument is not a valid JSON
document or the path argument is not a valid path expression or
contains a * or ** wildcard.
The result array is empty if the selected object is empty. If the
top-level value has nested subobjects, the return value does not
include keys from those subobjects.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html
mysql> SELECT JSON_KEYS('{"a": 1, "b": {"c": 30}}');
+---------------------------------------+
| JSON_KEYS('{"a": 1, "b": {"c": 30}}') |
+---------------------------------------+
| ["a", "b"] |
+---------------------------------------+
mysql> SELECT JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b');
+----------------------------------------------+
| JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b') |
+----------------------------------------------+
| ["c"] |
+----------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.htmlBM�[�@ (�� � "� 6JSON_SEARCH !Syntax:
JSON_SEARCH(json_doc, one_or_all, search_str[, escape_char[, path]
...])
Returns the path to the given string within a JSON document. Returns
NULL if any of the json_doc, search_str, or path arguments are NULL; no
path exists within the document; or search_str is not found. An error
occurs if the json_doc argument is not a valid JSON document, any path
argument is not a valid path expression, one_or_all is not 'one' or
'all', or escape_char is not a constant expression.
The one_or_all argument affects the search as follows:
o 'one': The search terminates after the first match and returns one
path string. It is undefined which match is considered first.
o 'all': The search returns all matching path strings such that no
duplicate paths are included. If there are multiple strings, they are
autowrapped as an array. The order of the array elements is
undefined.
Within the search_str search string argument, the % and _ characters
work as for the LIKE operator: % matches any number of characters
(including zero characters), and _ matches exactly one character.
To specify a literal % or _ character in the search string, precede it
by the escape character. The default is \ if the escape_char argument
is missing or NULL. Otherwise, escape_char must be a constant that is
empty or one character.
For more information about matching and escape character behavior, see
the description of LIKE in
https://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html
. For escape character handling, a difference from the LIKE behavior
is that the escape character for JSON_SEARCH() must evaluate to a
constant at compile time, not just at execution time. For example, if
JSON_SEARCH() is used in a prepared statement and the escape_char
argument is supplied using a ? parameter, the parameter value might be
constant at execution time, but is not at compile time.
search_str and path are always interpeted as utf8mb4 strings,
regardless of their actual encoding. This is a known issue which is
fixed in MySQL 8.0 ( Bug #32449181).
URL: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html
mysql> SET @j = '["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]';
mysql> SELECT JSON_SEARCH(@j, 'one', 'abc');
+-------------------------------+
| JSON_SEARCH(@j, 'one', 'abc') |
+-------------------------------+
| "$[0]" |
+-------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', 'abc');
+-------------------------------+
| JSON_SEARCH(@j, 'all', 'abc') |
+-------------------------------+
| ["$[0]", "$[2].x"] |
+-------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', 'ghi');
+-------------------------------+
| JSON_SEARCH(@j, 'all', 'ghi') |
+-------------------------------+
| NULL |
+-------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '10');
+------------------------------+
| JSON_SEARCH(@j, 'all', '10') |
+------------------------------+
| "$[1][0].k" |
+------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$');
+-----------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$') |
+-----------------------------------------+
| "$[1][0].k" |
+-----------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[*]');
+--------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[*]') |
+--------------------------------------------+
| "$[1][0].k" |
+--------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$**.k');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$**.k') |
+---------------------------------------------+
| "$[1][0].k" |
+---------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[*][0].k');
+-------------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[*][0].k') |
+-------------------------------------------------+
| "$[1][0].k" |
+-------------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[1]');
+--------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[1]') |
+--------------------------------------------+
| "$[1][0].k" |
+--------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[1][0]');
+-----------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[1][0]') |
+-----------------------------------------------+
| "$[1][0].k" |
+-----------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', 'abc', NULL, '$[2]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', 'abc', NULL, '$[2]') |
+---------------------------------------------+
| "$[2].x" |
+---------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '%a%');
+-------------------------------+
| JSON_SEARCH(@j, 'all', '%a%') |
+-------------------------------+
| ["$[0]", "$[2].x"] |
+-------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '%b%');
+-------------------------------+
| JSON_SEARCH(@j, 'all', '%b%') |
+-------------------------------+
| ["$[0]", "$[2].x", "$[3].y"] |
+-------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[0]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', NULL, '$[0]') |
+---------------------------------------------+
| "$[0]" |
+---------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[2]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', NULL, '$[2]') |
+---------------------------------------------+
| "$[2].x" |
+---------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[1]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', NULL, '$[1]') |
+---------------------------------------------+
| NULL |
+---------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', '', '$[1]');
+-------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', '', '$[1]') |
+-------------------------------------------+
| NULL |
+-------------------------------------------+
mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', '', '$[3]');
+-------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', '', '$[3]') |
+-------------------------------------------+
| "$[3].y" |
+-------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html p c�U.� ���G�f ! �&E� 5�� #� infimum supremumH ��@ ( � "� 6�JSON_APPEND !Syntax:
JSON_APPEND(json_doc, path, val[, path, val] ...)
Appends values to the end of the indicated arrays within a JSON
document and returns the result. This function was renamed to
JSON_ARRAY_APPEND() in MySQL 5.7.9; the alias JSON_APPEND() is now
deprecated in MySQL 5.7, and is removed in MySQL 8.0.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH�*�@ � � "� 6�JSON_ARRAY_APPEND !Syntax:
JSON_ARRAY_APPEND(json_doc, path, val[, path, val] ...)
Appends values to the end of the indicated arrays within a JSON
document and returns the result. Returns NULL if any argument is NULL.
An error occurs if the json_doc argument is not a valid JSON document
or any path argument is not a valid path expression or contains a * or
** wildcard.
The path-value pairs are evaluated left to right. The document produced
by evaluating one pair becomes the new value against which the next
pair is evaluated.
If a path selects a scalar or object value, that value is autowrapped
within an array and the new value is added to that array. Pairs for
which the path does not identify any value in the JSON document are
ignored.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SET @j = '["a", ["b", "c"], "d"]';
mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1]', 1);
+----------------------------------+
| JSON_ARRAY_APPEND(@j, '$[1]', 1) |
+----------------------------------+
| ["a", ["b", "c", 1], "d"] |
+----------------------------------+
mysql> SELECT JSON_ARRAY_APPEND(@j, '$[0]', 2);
+----------------------------------+
| JSON_ARRAY_APPEND(@j, '$[0]', 2) |
+----------------------------------+
| [["a", 2], ["b", "c"], "d"] |
+----------------------------------+
mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1][0]', 3);
+-------------------------------------+
| JSON_ARRAY_APPEND(@j, '$[1][0]', 3) |
+-------------------------------------+
| ["a", [["b", 3], "c"], "d"] |
+-------------------------------------+
mysql> SET @j = '{"a": 1, "b": [2, 3], "c": 4}';
mysql> SELECT JSON_ARRAY_APPEND(@j, '$.b', 'x');
+------------------------------------+
| JSON_ARRAY_APPEND(@j, '$.b', 'x') |
+------------------------------------+
| {"a": 1, "b": [2, 3, "x"], "c": 4} |
+------------------------------------+
mysql> SELECT JSON_ARRAY_APPEND(@j, '$.c', 'y');
+--------------------------------------+
| JSON_ARRAY_APPEND(@j, '$.c', 'y') |
+--------------------------------------+
| {"a": 1, "b": [2, 3], "c": [4, "y"]} |
+--------------------------------------+
mysql> SET @j = '{"a": 1}';
mysql> SELECT JSON_ARRAY_APPEND(@j, '$', 'z');
+---------------------------------+
| JSON_ARRAY_APPEND(@j, '$', 'z') |
+---------------------------------+
| [{"a": 1}, "z"] |
+---------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH���@
� "� 6�JSON_ARRAY_INSERT !Syntax:
JSON_ARRAY_INSERT(json_doc, path, val[, path, val] ...)
Updates a JSON document, inserting into an array within the document
and returning the modified document. Returns NULL if any argument is
NULL. An error occurs if the json_doc argument is not a valid JSON
document or any path argument is not a valid path expression or
contains a * or ** wildcard or does not end with an array element
identifier.
The path-value pairs are evaluated left to right. The document produced
by evaluating one pair becomes the new value against which the next
pair is evaluated.
Pairs for which the path does not identify any array in the JSON
document are ignored. If a path identifies an array element, the
corresponding value is inserted at that element position, shifting any
following values to the right. If a path identifies an array position
past the end of an array, the value is inserted at the end of the
array.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SET @j = '["a", {"b": [1, 2]}, [3, 4]]';
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1]', 'x');
+------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[1]', 'x') |
+------------------------------------+
| ["a", "x", {"b": [1, 2]}, [3, 4]] |
+------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[100]', 'x');
+--------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[100]', 'x') |
+--------------------------------------+
| ["a", {"b": [1, 2]}, [3, 4], "x"] |
+--------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x');
+-----------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x') |
+-----------------------------------------+
| ["a", {"b": ["x", 1, 2]}, [3, 4]] |
+-----------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[2][1]', 'y');
+---------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[2][1]', 'y') |
+---------------------------------------+
| ["a", {"b": [1, 2]}, [3, "y", 4]] |
+---------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y');
+----------------------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y') |
+----------------------------------------------------+
| ["x", "a", {"b": [1, 2]}, [3, 4]] |
+----------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlHA�/�@ ( � "� 6�JSON_INSERT !Syntax:
JSON_INSERT(json_doc, path, val[, path, val] ...)
Inserts data into a JSON document and returns the result. Returns NULL
if any argument is NULL. An error occurs if the json_doc argument is
not a valid JSON document or any path argument is not a valid path
expression or contains a * or ** wildcard.
The path-value pairs are evaluated left to right. The document produced
by evaluating one pair becomes the new value against which the next
pair is evaluated.
A path-value pair for an existing path in the document is ignored and
does not overwrite the existing document value. A path-value pair for a
nonexisting path in the document adds the value to the document if the
path identifies one of these types of values:
o A member not present in an existing object. The member is added to
the object and associated with the new value.
o A position past the end of an existing array. The array is extended
with the new value. If the existing value is not an array, it is
autowrapped as an array, then extended with the new value.
Otherwise, a path-value pair for a nonexisting path in the document is
ignored and has no effect.
For a comparison of JSON_INSERT(), JSON_REPLACE(), and JSON_SET(), see
the discussion of JSON_SET().
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');
+----------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]') |
+----------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": "[true, false]"} |
+----------------------------------------------------+
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON));
+------------------------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON)) |
+------------------------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": [true, false]} |
+------------------------------------------------------------------+
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH@��@ 0� � "� 6�JSON_MERGE !Syntax:
JSON_MERGE(json_doc, json_doc[, json_doc] ...)
Merges two or more JSON documents. Synonym for JSON_MERGE_PRESERVE();
deprecated in MySQL 5.7.22 and subject to removal in a future release.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SELECT JSON_MERGE('[1, 2]', '[true, false]');
+---------------------------------------+
| JSON_MERGE('[1, 2]', '[true, false]') |
+---------------------------------------+
| [1, 2, true, false] |
+---------------------------------------+
1 row in set, 1 warning (0.00 sec)
mysql> SHOW WARNINGS\G
*************************** 1. row ***************************
Level: Warning
Code: 1287
Message: 'JSON_MERGE' is deprecated and will be removed in a future release. \
Please use JSON_MERGE_PRESERVE/JSON_MERGE_PATCH instead
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH��Ɔ@ 8ܪ � "� 6�JSON_MERGE_PATCH() !Syntax:
JSON_MERGE_PATCH(json_doc, json_doc[, json_doc] ...)
Performs an RFC 7396 (https://tools.ietf.org/html/rfc7396) compliant
merge of two or more JSON documents and returns the merged result,
without preserving members having duplicate keys. Raises an error if at
least one of the documents passed as arguments to this function is not
valid.
*Note*:
For an explanation and example of the differences between this function
and JSON_MERGE_PRESERVE(), see
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
#json-merge-patch-json-merge-preserve-compared.
JSON_MERGE_PATCH() performs a merge as follows:
1. If the first argument is not an object, the result of the merge is
the same as if an empty object had been merged with the second
argument.
2. If the second argument is not an object, the result of the merge is
the second argument.
3. If both arguments are objects, the result of the merge is an object
with the following members:
o All members of the first object which do not have a corresponding
member with the same key in the second object.
o All members of the second object which do not have a corresponding
key in the first object, and whose value is not the JSON null
literal.
o All members with a key that exists in both the first and the second
object, and whose value in the second object is not the JSON null
literal. The values of these members are the results of recursively
merging the value in the first object with the value in the second
object.
For additional information, see
https://dev.mysql.com/doc/refman/5.7/en/json.html#json-normalization.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '[true, false]');
+---------------------------------------------+
| JSON_MERGE_PATCH('[1, 2]', '[true, false]') |
+---------------------------------------------+
| [true, false] |
+---------------------------------------------+
mysql> SELECT JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}');
+-------------------------------------------------+
| JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}') |
+-------------------------------------------------+
| {"id": 47, "name": "x"} |
+-------------------------------------------------+
mysql> SELECT JSON_MERGE_PATCH('1', 'true');
+-------------------------------+
| JSON_MERGE_PATCH('1', 'true') |
+-------------------------------+
| true |
+-------------------------------+
mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '{"id": 47}');
+------------------------------------------+
| JSON_MERGE_PATCH('[1, 2]', '{"id": 47}') |
+------------------------------------------+
| {"id": 47} |
+------------------------------------------+
mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }',
> '{ "a": 3, "c":4 }');
+-----------------------------------------------------------+
| JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }') |
+-----------------------------------------------------------+
| {"a": 3, "b": 2, "c": 4} |
+-----------------------------------------------------------+
mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }',
> '{ "a": 5, "d":6 }');
+-------------------------------------------------------------------------------+
| JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }','{ "a": 5, "d":6 }') |
+-------------------------------------------------------------------------------+
| {"a": 5, "b": 2, "c": 4, "d": 6} |
+-------------------------------------------------------------------------------+
mysql> SELECT JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}');
+--------------------------------------------------+
| JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}') |
+--------------------------------------------------+
| {"a": 1} |
+--------------------------------------------------+
mysql> SELECT JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}');
+----------------------------------------------------+
| JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}') |
+----------------------------------------------------+
| {"a": {"x": 1, "y": 2}} |
+----------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html p c�G�f �&�� ! " 5�E� 4�� -� infimum supremumHd��@ � � "� 6�JSON_MERGE_PRESERVE() !Syntax:
JSON_MERGE_PRESERVE(json_doc, json_doc[, json_doc] ...)
Merges two or more JSON documents and returns the merged result.
Returns NULL if any argument is NULL. An error occurs if any argument
is not a valid JSON document.
Merging takes place according to the following rules. For additional
information, see
https://dev.mysql.com/doc/refman/5.7/en/json.html#json-normalization.
o Adjacent arrays are merged to a single array.
o Adjacent objects are merged to a single object.
o A scalar value is autowrapped as an array and merged as an array.
o An adjacent array and object are merged by autowrapping the object as
an array and merging the two arrays.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '[true, false]');
+------------------------------------------------+
| JSON_MERGE_PRESERVE('[1, 2]', '[true, false]') |
+------------------------------------------------+
| [1, 2, true, false] |
+------------------------------------------------+
mysql> SELECT JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}');
+----------------------------------------------------+
| JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}') |
+----------------------------------------------------+
| {"id": 47, "name": "x"} |
+----------------------------------------------------+
mysql> SELECT JSON_MERGE_PRESERVE('1', 'true');
+----------------------------------+
| JSON_MERGE_PRESERVE('1', 'true') |
+----------------------------------+
| [1, true] |
+----------------------------------+
mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}');
+---------------------------------------------+
| JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}') |
+---------------------------------------------+
| [1, 2, {"id": 47}] |
+---------------------------------------------+
mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }',
> '{ "a": 3, "c": 4 }');
+--------------------------------------------------------------+
| JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c":4 }') |
+--------------------------------------------------------------+
| {"a": [1, 3], "b": 2, "c": 4} |
+--------------------------------------------------------------+
mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }',
> '{ "a": 5, "d": 6 }');
+----------------------------------------------------------------------------------+
| JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }','{ "a": 5, "d": 6 }') |
+----------------------------------------------------------------------------------+
| {"a": [1, 3, 5], "b": 2, "c": 4, "d": 6} |
+----------------------------------------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH݀��@ * � "� 6�JSON_REMOVE !Syntax:
JSON_REMOVE(json_doc, path[, path] ...)
Removes data from a JSON document and returns the result. Returns NULL
if any argument is NULL. An error occurs if the json_doc argument is
not a valid JSON document or any path argument is not a valid path
expression or is $ or contains a * or ** wildcard.
The path arguments are evaluated left to right. The document produced
by evaluating one path becomes the new value against which the next
path is evaluated.
It is not an error if the element to be removed does not exist in the
document; in that case, the path does not affect the document.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SET @j = '["a", ["b", "c"], "d"]';
mysql> SELECT JSON_REMOVE(@j, '$[1]');
+-------------------------+
| JSON_REMOVE(@j, '$[1]') |
+-------------------------+
| ["a", "d"] |
+-------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH��`�@ � � "� 6�JSON_REPLACE !Syntax:
JSON_REPLACE(json_doc, path, val[, path, val] ...)
Replaces existing values in a JSON document and returns the result.
Returns NULL if any argument is NULL. An error occurs if the json_doc
argument is not a valid JSON document or any path argument is not a
valid path expression or contains a * or ** wildcard.
The path-value pairs are evaluated left to right. The document produced
by evaluating one pair becomes the new value against which the next
pair is evaluated.
A path-value pair for an existing path in the document overwrites the
existing document value with the new value. A path-value pair for a
nonexisting path in the document is ignored and has no effect.
For a comparison of JSON_INSERT(), JSON_REPLACE(), and JSON_SET(), see
the discussion of JSON_SET().
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');
+-----------------------------------------------------+
| JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]') |
+-----------------------------------------------------+
| {"a": 10, "b": [2, 3]} |
+-----------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH ��@ (
� � "� 6JSON_SET !Syntax:
JSON_SET(json_doc, path, val[, path, val] ...)
Inserts or updates data in a JSON document and returns the result.
Returns NULL if json_doc or path is NULL, or if path, when given, does
not locate an object. Otherwise, an error occurs if the json_doc
argument is not a valid JSON document or any path argument is not a
valid path expression or contains a * or ** wildcard.
The path-value pairs are evaluated left to right. The document produced
by evaluating one pair becomes the new value against which the next
pair is evaluated.
A path-value pair for an existing path in the document overwrites the
existing document value with the new value. A path-value pair for a
nonexisting path in the document adds the value to the document if the
path identifies one of these types of values:
o A member not present in an existing object. The member is added to
the object and associated with the new value.
o A position past the end of an existing array. The array is extended
with the new value. If the existing value is not an array, it is
autowrapped as an array, then extended with the new value.
Otherwise, a path-value pair for a nonexisting path in the document is
ignored and has no effect.
The JSON_SET(), JSON_INSERT(), and JSON_REPLACE() functions are
related:
o JSON_SET() replaces existing values and adds nonexisting values.
o JSON_INSERT() inserts values without replacing existing values.
o JSON_REPLACE() replaces only existing values.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_SET(@j, '$.a', 10, '$.c', '[true, false]');
+-------------------------------------------------+
| JSON_SET(@j, '$.a', 10, '$.c', '[true, false]') |
+-------------------------------------------------+
| {"a": 10, "b": [2, 3], "c": "[true, false]"} |
+-------------------------------------------------+
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');
+----------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]') |
+----------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": "[true, false]"} |
+----------------------------------------------------+
mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');
+-----------------------------------------------------+
| JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]') |
+-----------------------------------------------------+
| {"a": 10, "b": [2, 3]} |
+-----------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlH��>�@ 0� � "� 6JSON_UNQUOTE !Syntax:
JSON_UNQUOTE(json_val)
Unquotes JSON value and returns the result as a utf8mb4 string. Returns
NULL if the argument is NULL. An error occurs if the value starts and
ends with double quotes but is not a valid JSON string literal.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
mysql> SET @j = '"abc"';
mysql> SELECT @j, JSON_UNQUOTE(@j);
+-------+------------------+
| @j | JSON_UNQUOTE(@j) |
+-------+------------------+
| "abc" | abc |
+-------+------------------+
mysql> SET @j = '[1, 2, 3]';
mysql> SELECT @j, JSON_UNQUOTE(@j);
+-----------+------------------+
| @j | JSON_UNQUOTE(@j) |
+-----------+------------------+
| [1, 2, 3] | [1, 2, 3] |
+-----------+------------------+
mysql> SELECT @@sql_mode;
+------------+
| @@sql_mode |
+------------+
| |
+------------+
mysql> SELECT JSON_UNQUOTE('"\\t\\u0032"');
+------------------------------+
| JSON_UNQUOTE('"\\t\\u0032"') |
+------------------------------+
| 2 |
+------------------------------+
mysql> SET @@sql_mode = 'NO_BACKSLASH_ESCAPES';
mysql> SELECT JSON_UNQUOTE('"\\t\\u0032"');
+------------------------------+
| JSON_UNQUOTE('"\\t\\u0032"') |
+------------------------------+
| \t\u0032 |
+------------------------------+
mysql> SELECT JSON_UNQUOTE('"\t\u0032"');
+----------------------------+
| JSON_UNQUOTE('"\t\u0032"') |
+----------------------------+
| 2 |
+----------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlE���@ 8 � "� 6JSON_DEPTH !Syntax:
JSON_DEPTH(json_doc)
Returns the maximum depth of a JSON document. Returns NULL if the
argument is NULL. An error occurs if the argument is not a valid JSON
document.
An empty array, empty object, or scalar value has depth 1. A nonempty
array containing only elements of depth 1 or nonempty object containing
only member values of depth 1 has depth 2. Otherwise, a JSON document
has depth greater than 2.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html
mysql> SELECT JSON_DEPTH('{}'), JSON_DEPTH('[]'), JSON_DEPTH('true');
+------------------+------------------+--------------------+
| JSON_DEPTH('{}') | JSON_DEPTH('[]') | JSON_DEPTH('true') |
+------------------+------------------+--------------------+
| 1 | 1 | 1 |
+------------------+------------------+--------------------+
mysql> SELECT JSON_DEPTH('[10, 20]'), JSON_DEPTH('[[], {}]');
+------------------------+------------------------+
| JSON_DEPTH('[10, 20]') | JSON_DEPTH('[[], {}]') |
+------------------------+------------------------+
| 2 | 2 |
+------------------------+------------------------+
mysql> SELECT JSON_DEPTH('[10, {"a": 20}]');
+-------------------------------+
| JSON_DEPTH('[10, {"a": 20}]') |
+-------------------------------+
| 3 |
+-------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.htmlE3��@ @ү � "� 6(JSON_LENGTH !Syntax:
JSON_LENGTH(json_doc[, path])
Returns the length of a JSON document, or, if a path argument is given,
the length of the value within the document identified by the path.
Returns NULL if any argument is NULL or the path argument does not
identify a value in the document. An error occurs if the json_doc
argument is not a valid JSON document or the path argument is not a
valid path expression or contains a * or ** wildcard.
The length of a document is determined as follows:
o The length of a scalar is 1.
o The length of an array is the number of array elements.
o The length of an object is the number of object members.
o The length does not count the length of nested arrays or objects.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html
mysql> SELECT JSON_LENGTH('[1, 2, {"a": 3}]');
+---------------------------------+
| JSON_LENGTH('[1, 2, {"a": 3}]') |
+---------------------------------+
| 3 |
+---------------------------------+
mysql> SELECT JSON_LENGTH('{"a": 1, "b": {"c": 30}}');
+-----------------------------------------+
| JSON_LENGTH('{"a": 1, "b": {"c": 30}}') |
+-----------------------------------------+
| 2 |
+-----------------------------------------+
mysql> SELECT JSON_LENGTH('{"a": 1, "b": {"c": 30}}', '$.b');
+------------------------------------------------+
| JSON_LENGTH('{"a": 1, "b": {"c": 30}}', '$.b') |
+------------------------------------------------+
| 1 |
+------------------------------------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html p c�� 5��| " ! # {�E� 8 � 2 infimum supremumE V�@ � � "� 65JSON_TYPE !Syntax:
JSON_TYPE(json_val)
Returns a utf8mb4 string indicating the type of a JSON value. This can
be an object, an array, or a scalar type, as shown here:
mysql> SET @j = '{"a": [10, true]}';
mysql> SELECT JSON_TYPE(@j);
+---------------+
| JSON_TYPE(@j) |
+---------------+
| OBJECT |
+---------------+
mysql> SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a'));
+------------------------------------+
| JSON_TYPE(JSON_EXTRACT(@j, '$.a')) |
+------------------------------------+
| ARRAY |
+------------------------------------+
mysql> SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a[0]'));
+---------------------------------------+
| JSON_TYPE(JSON_EXTRACT(@j, '$.a[0]')) |
+---------------------------------------+
| INTEGER |
+---------------------------------------+
mysql> SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a[1]'));
+---------------------------------------+
| JSON_TYPE(JSON_EXTRACT(@j, '$.a[1]')) |
+---------------------------------------+
| BOOLEAN |
+---------------------------------------+
JSON_TYPE() returns NULL if the argument is NULL:
mysql> SELECT JSON_TYPE(NULL);
+-----------------+
| JSON_TYPE(NULL) |
+-----------------+
| NULL |
+-----------------+
An error occurs if the argument is not a valid JSON value:
mysql> SELECT JSON_TYPE(1);
ERROR 3146 (22032): Invalid data type for JSON data in argument 1
to function json_type; a JSON string or JSON type is required.
For a non-NULL, non-error result, the following list describes the
possible JSON_TYPE() return values:
o Purely JSON types:
o OBJECT: JSON objects
o ARRAY: JSON arrays
o BOOLEAN: The JSON true and false literals
o NULL: The JSON null literal
o Numeric types:
o INTEGER: MySQL TINYINT, SMALLINT, MEDIUMINT and INT and BIGINT
scalars
o DOUBLE: MySQL DOUBLE FLOAT scalars
o DECIMAL: MySQL DECIMAL and NUMERIC scalars
o Temporal types:
o DATETIME: MySQL DATETIME and TIMESTAMP scalars
o DATE: MySQL DATE scalars
o TIME: MySQL TIME scalars
o String types:
o STRING: MySQL utf8 character type scalars: CHAR, VARCHAR, TEXT,
ENUM, and SET
o Binary types:
o BLOB: MySQL binary type scalars: BINARY, VARBINARY, BLOB
o BIT: MySQL BIT scalars
o All other types:
o OPAQUE (raw bits)
URL: https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html
https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.htmlEׁƀ@ @ � "� 6BJSON_VALID !Syntax:
JSON_VALID(val)
Returns 0 or 1 to indicate whether a value is valid JSON. Returns NULL
if the argument is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html
mysql> SELECT JSON_VALID('{"a": 1}');
+------------------------+
| JSON_VALID('{"a": 1}') |
+------------------------+
| 1 |
+------------------------+
mysql> SELECT JSON_VALID('hello'), JSON_VALID('"hello"');
+---------------------+-----------------------+
| JSON_VALID('hello') | JSON_VALID('"hello"') |
+---------------------+-----------------------+
| 0 | 1 |
+---------------------+-----------------------+
https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.htmlC���@
] � "� 6OJSON_PRETTY !JSON_PRETTY(json_val)
Provides pretty-printing of JSON values similar to that implemented in
PHP and by other languages and database systems. The value supplied
must be a JSON value or a valid string representation of a JSON value.
Extraneous whitespaces and newlines present in this value have no
effect on the output. For a NULL value, the function returns NULL. If
the value is not a JSON document, or if it cannot be parsed as one, the
function fails with an error.
Formatting of the output from this function adheres to the following
rules:
o Each array element or object member appears on a separate line,
indented by one additional level as compared to its parent.
o Each level of indentation adds two leading spaces.
o A comma separating individual array elements or object members is
printed before the newline that separates the two elements or
members.
o The key and the value of an object member are separated by a colon
followed by a space (': ').
o An empty object or array is printed on a single line. No space is
printed between the opening and closing brace.
o Special characters in string scalars and key names are escaped
employing the same rules used by the JSON_QUOTE() function.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-utility-functions.html
mysql> SELECT JSON_PRETTY('123'); # scalar
+--------------------+
| JSON_PRETTY('123') |
+--------------------+
| 123 |
+--------------------+
mysql> SELECT JSON_PRETTY("[1,3,5]"); # array
+------------------------+
| JSON_PRETTY("[1,3,5]") |
+------------------------+
| [
1,
3,
5
] |
+------------------------+
mysql> SELECT JSON_PRETTY('{"a":"10","b":"15","x":"25"}'); # object
+---------------------------------------------+
| JSON_PRETTY('{"a":"10","b":"15","x":"25"}') |
+---------------------------------------------+
| {
"a": "10",
"b": "15",
"x": "25"
} |
+---------------------------------------------+
mysql> SELECT JSON_PRETTY('["a",1,{"key1":
> "value1"},"5", "77" ,
> {"key2":["value3","valueX",
> "valueY"]},"j", "2" ]')\G # nested arrays and objects
*************************** 1. row ***************************
JSON_PRETTY('["a",1,{"key1":
"value1"},"5", "77" ,
{"key2":["value3","valuex",
"valuey"]},"j", "2" ]'): [
"a",
1,
{
"key1": "value1"
},
"5",
"77",
{
"key2": [
"value3",
"valuex",
"valuey"
]
},
"j",
"2"
]
https://dev.mysql.com/doc/refman/5.7/en/json-utility-functions.htmlCH�̂@ (� � "� 6\JSON_STORAGE_SIZE !JSON_STORAGE_SIZE(json_val)
This function returns the number of bytes used to store the binary
representation of a JSON document. When the argument is a JSON column,
this is the space used to store the JSON document. json_val must be a
valid JSON document or a string which can be parsed as one. In the case
where it is string, the function returns the amount of storage space in
the JSON binary representation that is created by parsing the string as
JSON and converting it to binary. It returns NULL if the argument is
NULL.
An error results when json_val is not NULL, and is not---or cannot be
successfully parsed as---a JSON document.
URL: https://dev.mysql.com/doc/refman/5.7/en/json-utility-functions.html
mysql> CREATE TABLE jtable (jcol JSON);
Query OK, 0 rows affected (0.42 sec)
mysql> INSERT INTO jtable VALUES
-> ('{"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"}');
Query OK, 1 row affected (0.04 sec)
mysql> SELECT
-> jcol,
-> JSON_STORAGE_SIZE(jcol) AS Size
-> FROM jtable;
+-----------------------------------------------+------+
| jcol | Size |
+-----------------------------------------------+------+
| {"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"} | 47 |
+-----------------------------------------------+------+
1 row in set (0.00 sec)
mysql> UPDATE jtable
mysql> SET jcol = '{"a": 4.55, "b": "wxyz", "c": "[true, false]"}';
Query OK, 1 row affected (0.04 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> SELECT
-> jcol,
-> JSON_STORAGE_SIZE(jcol) AS Size
-> FROM jtable;
+------------------------------------------------+------+
| jcol | Size |
+------------------------------------------------+------+
| {"a": 4.55, "b": "wxyz", "c": "[true, false]"} | 56 |
+------------------------------------------------+------+
1 row in set (0.00 sec)
mysql> SET @j = '[100, "sakila", [1, 3, 5], 425.05]';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
+------------------------------------+------+
| @j | Size |
+------------------------------------+------+
| [100, "sakila", [1, 3, 5], 425.05] | 45 |
+------------------------------------+------+
1 row in set (0.00 sec)
mysql> SET @j = JSON_SET(@j, '$[1]', "json");
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
+----------------------------------+------+
| @j | Size |
+----------------------------------+------+
| [100, "json", [1, 3, 5], 425.05] | 43 |
+----------------------------------+------+
1 row in set (0.00 sec)
mysql> SET @j = JSON_SET(@j, '$[2][0]', JSON_ARRAY(10, 20, 30));
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
+---------------------------------------------+------+
| @j | Size |
+---------------------------------------------+------+
| [100, "json", [[10, 20, 30], 3, 5], 425.05] | 56 |
+---------------------------------------------+------+
1 row in set (0.00 sec)
mysql> SELECT
-> JSON_STORAGE_SIZE('[100, "sakila", [1, 3, 5], 425.05]') AS A,
-> JSON_STORAGE_SIZE('{"a": 1000, "b": "a", "c": "[1, 3, 5, 7]"}') AS B,
-> JSON_STORAGE_SIZE('{"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"}') AS C,
-> JSON_STORAGE_SIZE('[100, "json", [[10, 20, 30], 3, 5], 425.05]') AS D;
+----+----+----+----+
| A | B | C | D |
+----+----+----+----+
| 45 | 44 | 47 | 56 |
+----+----+----+----+
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/json-utility-functions.html;׃�@ 0` � "� 6iGTID_SUBSET "Syntax:
GTID_SUBSET(set1,set2)
Given two sets of global transaction identifiers set1 and set2, returns
true if all GTIDs in set1 are also in set2. Returns false otherwise.
URL: https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html
mysql> SELECT GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23',
-> '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')\G
*************************** 1. row ***************************
GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23',
'3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'): 1
1 row in set (0.00 sec)
mysql> SELECT GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23-25',
-> '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')\G
*************************** 1. row ***************************
GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23-25',
'3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'): 1
1 row in set (0.00 sec)
mysql> SELECT GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25',
-> '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')\G
*************************** 1. row ***************************
GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25',
'3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'): 0
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html;d�ހ@ 8� � "� 6vGTID_SUBTRACT "Syntax:
GTID_SUBTRACT(set1,set2)
Given two sets of global transaction identifiers set1 and set2, returns
only those GTIDs from set1 that are not in set2.
URL: https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html
mysql> SELECT GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
-> '3E11FA47-71CA-11E1-9E33-C80AA9429562:21')\G
*************************** 1. row ***************************
GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
'3E11FA47-71CA-11E1-9E33-C80AA9429562:21'): 3e11fa47-71ca-11e1-9e33-c80aa9429562:22-57
1 row in set (0.00 sec)
mysql> SELECT GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
-> '3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25')\G
*************************** 1. row ***************************
GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
'3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25'): 3e11fa47-71ca-11e1-9e33-c80aa9429562:26-57
1 row in set (0.00 sec)
mysql> SELECT GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
-> '3E11FA47-71CA-11E1-9E33-C80AA9429562:23-24')\G
*************************** 1. row ***************************
GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
'3E11FA47-71CA-11E1-9E33-C80AA9429562:23-24'): 3e11fa47-71ca-11e1-9e33-c80aa9429562:21-22:25-57
1 row in set (0.01 sec)
https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html;c'�@ @�i � "� 6�WAIT_FOR_EXECUTED_GTID_SET "Syntax:
WAIT_FOR_EXECUTED_GTID_SET(gtid_set[, timeout])
Wait until the server has applied all of the transactions whose global
transaction identifiers are contained in gtid_set; that is, until the
condition GTID_SUBSET(gtid_subset, @@GLOBAL.gtid_executed) holds. See
https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-concepts.html
for a definition of GTID sets.
If a timeout is specified, and timeout seconds elapse before all of the
transactions in the GTID set have been applied, the function stops
waiting. timeout is optional, and the default timeout is 0 seconds, in
which case the function always waits until all of the transactions in
the GTID set have been applied. timeout must be greater than or equal
to 0; as of MySQL 5.7.18, when running in strict SQL mode, a negative
timeout value is immediately rejected with an error; otherwise the
function returns NULL, and raises a warning.
WAIT_FOR_EXECUTED_GTID_SET() monitors all the GTIDs that are applied on
the server, including transactions that arrive from all replication
channels and user clients. It does not take into account whether
replication channels have been started or stopped.
For more information, see
https://dev.mysql.com/doc/refman/5.7/en/replication-gtids.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html
mysql> SELECT WAIT_FOR_EXECUTED_GTID_SET('3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5');
-> 0
https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html p c�| {�q0 # " $ �-E� 7�� 5� infimum supremum; ��@ I � "� 6�WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS "Syntax:
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS(gtid_set[, timeout][,channel])
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() is similar to
WAIT_FOR_EXECUTED_GTID_SET() in that it waits until all of the
transactions whose global transaction identifiers are contained in
gtid_set have been applied, or until timeout seconds have elapsed,
whichever occurs first. However, WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS()
applies to a specific replication channel, and stops only after the
transactions have been applied on the specified channel, for which the
applier must be running. In contrast, WAIT_FOR_EXECUTED_GTID_SET()
stops after the transactions have been applied, regardless of where
they were applied (on any replication channel or any user client), and
whether or not any replication channels are running.
timeout must be greater than or equal to 0; as of MySQL 5.7.18, when
running in strict SQL mode, a negative timeout value is immediately
rejected with an error (ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments)); otherwise
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() returns NULL, and raises a warning.
The channel option names which replication channel the function applies
to. If no channel is named and no channels other than the default
replication channel exist, the function applies to the default
replication channel. If multiple replication channels exist, you must
specify a channel as otherwise it is not known which replication
channel the function applies to. See
https://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information on replication channels.
*Note*:
Because WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() applies to a specific
replication channel, if an expected transaction arrives on a different
replication channel or from a user client, for example in a failover or
manual recovery situation, the function can hang indefinitely if no
timeout is set. Use WAIT_FOR_EXECUTED_GTID_SET() instead to ensure
correct handling of transactions in these situations.
GTID sets used with WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() are represented
as strings and must be quoted in the same way as for
WAIT_FOR_EXECUTED_GTID_SET(). For WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS(),
the return value for the function is an arbitrary positive number. If
GTID-based replication is not active (that is, if the value of the
gtid_mode variable is OFF), then this value is undefined and
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() returns NULL. If the replica is not
running then the function also returns NULL.
gtid_mode cannot be changed to OFF while any client is using this
function to wait for GTIDs to be applied.
URL: https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html
https://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html@^�@ � "� 6�AVG #Syntax:
AVG([DISTINCT] expr)
Returns the average value of expr. The DISTINCT option can be used to
return the average of the distinct values of expr.
If there are no matching rows, AVG() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT student_name, AVG(test_score)
FROM student
GROUP BY student_name;
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ �@ � � "� 6�BIT_AND #Syntax:
BIT_AND(expr)
Returns the bitwise AND of all bits in expr. The calculation is
performed with 64-bit (BIGINT) precision.
If there are no matching rows, BIT_AND() returns a neutral value (all
bits set to 1).
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ �@ (� � "� 6�BIT_OR #Syntax:
BIT_OR(expr)
Returns the bitwise OR of all bits in expr. The calculation is
performed with 64-bit (BIGINT) precision.
If there are no matching rows, BIT_OR() returns a neutral value (all
bits set to 0).
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ �@ 0� � "� 6�BIT_XOR #Syntax:
BIT_XOR(expr)
Returns the bitwise XOR of all bits in expr. The calculation is
performed with 64-bit (BIGINT) precision.
If there are no matching rows, BIT_XOR() returns a neutral value (all
bits set to 0).
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@���@ 8H � "� 6�COUNT #Syntax:
COUNT(expr)
Returns a count of the number of non-NULL values of expr in the rows
retrieved by a SELECT statement. The result is a BIGINT value.
If there are no matching rows, COUNT() returns 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT student.student_name,COUNT(*)
FROM student,course
WHERE student.student_id=course.student_id
GROUP BY student_name;
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@4��@ @� � "� 6�COUNT DISTINCT #Syntax:
COUNT(DISTINCT expr,[expr...])
Returns a count of the number of rows with different non-NULL expr
values.
If there are no matching rows, COUNT(DISTINCT) returns 0.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT COUNT(DISTINCT results) FROM student;
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@pŁ@ H� � "� 6�GROUP_CONCAT #Syntax:
GROUP_CONCAT(expr)
This function returns a string result with the concatenated non-NULL
values from a group. It returns NULL if there are no non-NULL values.
The full syntax is as follows:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT student_name,
GROUP_CONCAT(test_score)
FROM student
GROUP BY student_name;
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@\���@ P� � "� 6�JSON_ARRAYAGG #Syntax:
JSON_ARRAYAGG(col_or_expr)
Aggregates a result set as a single JSON array whose elements consist
of the rows. The order of elements in this array is undefined. The
function acts on a column or an expression that evaluates to a single
value. Returns NULL if the result contains no rows, or in the event of
an error.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT o_id, attribute, value FROM t3;
+------+-----------+-------+
| o_id | attribute | value |
+------+-----------+-------+
| 2 | color | red |
| 2 | fabric | silk |
| 3 | color | green |
| 3 | shape | square|
+------+-----------+-------+
4 rows in set (0.00 sec)
mysql> SELECT o_id, JSON_ARRAYAGG(attribute) AS attributes
-> FROM t3 GROUP BY o_id;
+------+---------------------+
| o_id | attributes |
+------+---------------------+
| 2 | ["color", "fabric"] |
| 3 | ["color", "shape"] |
+------+---------------------+
2 rows in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@��@ X � "� 6JSON_OBJECTAGG #Syntax:
JSON_OBJECTAGG(key, value)
Takes two column names or expressions as arguments, the first of these
being used as a key and the second as a value, and returns a JSON
object containing key-value pairs. Returns NULL if the result contains
no rows, or in the event of an error. An error occurs if any key name
is NULL or the number of arguments is not equal to 2.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT o_id, attribute, value FROM t3;
+------+-----------+-------+
| o_id | attribute | value |
+------+-----------+-------+
| 2 | color | red |
| 2 | fabric | silk |
| 3 | color | green |
| 3 | shape | square|
+------+-----------+-------+
4 rows in set (0.00 sec)
mysql> SELECT o_id, JSON_OBJECTAGG(attribute, value)
-> FROM t3 GROUP BY o_id;
+------+---------------------------------------+
| o_id | JSON_OBJECTAGG(attribute, value) |
+------+---------------------------------------+
| 2 | {"color": "red", "fabric": "silk"} |
| 3 | {"color": "green", "shape": "square"} |
+------+---------------------------------------+
2 rows in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@o�@ `� � "� 6MAX #Syntax:
MAX([DISTINCT] expr)
Returns the maximum value of expr. MAX() may take a string argument; in
such cases, it returns the maximum string value. See
https://dev.mysql.com/doc/refman/5.7/en/mysql-indexes.html. The
DISTINCT keyword can be used to find the maximum of the distinct values
of expr, however, this produces the same result as omitting DISTINCT.
If there are no matching rows, MAX() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
FROM student
GROUP BY student_name;
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@o�@ h� � "� 6 MIN #Syntax:
MIN([DISTINCT] expr)
Returns the minimum value of expr. MIN() may take a string argument; in
such cases, it returns the minimum string value. See
https://dev.mysql.com/doc/refman/5.7/en/mysql-indexes.html. The
DISTINCT keyword can be used to find the minimum of the distinct values
of expr, however, this produces the same result as omitting DISTINCT.
If there are no matching rows, MIN() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
FROM student
GROUP BY student_name;
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ �@ p� � "� 6,STD #Syntax:
STD(expr)
Returns the population standard deviation of expr. STD() is a synonym
for the standard SQL function STDDEV_POP(), provided as a MySQL
extension.
If there are no matching rows, STD() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ 2�@ x� � "� 69STDDEV #Syntax:
STDDEV(expr)
Returns the population standard deviation of expr. STDDEV() is a
synonym for the standard SQL function STDDEV_POP(), provided for
compatibility with Oracle.
If there are no matching rows, STDDEV() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ >�@ �� � "� 6FSTDDEV_POP #Syntax:
STDDEV_POP(expr)
Returns the population standard deviation of expr (the square root of
VAR_POP()). You can also use STD() or STDDEV(), which are equivalent
but not standard SQL.
If there are no matching rows, STDDEV_POP() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ �@ �� � "� 6SSTDDEV_SAMP #Syntax:
STDDEV_SAMP(expr)
Returns the sample standard deviation of expr (the square root of
VAR_SAMP().
If there are no matching rows, STDDEV_SAMP() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ 0�@ �� � "� 6`SUM #Syntax:
SUM([DISTINCT] expr)
Returns the sum of expr. If the return set has no rows, SUM() returns
NULL. The DISTINCT keyword can be used to sum only the distinct values
of expr.
If there are no matching rows, SUM() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ ��@ � � "� 6mVAR_POP #Syntax:
VAR_POP(expr)
Returns the population standard variance of expr. It considers rows as
the whole population, not as a sample, so it has the number of rows as
the denominator. You can also use VARIANCE(), which is equivalent but
is not standard SQL.
If there are no matching rows, VAR_POP() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ ��@ �� � "� 6zVAR_SAMP #Syntax:
VAR_SAMP(expr)
Returns the sample variance of expr. That is, the denominator is the
number of rows minus one.
If there are no matching rows, VAR_SAMP() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html@ +�@ �ʑ � "� 6�VARIANCE #Syntax:
VARIANCE(expr)
Returns the population standard variance of expr. VARIANCE() is a
synonym for the standard SQL function VAR_POP(), provided as a MySQL
extension.
If there are no matching rows, VARIANCE() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html
https://dev.mysql.com/doc/refman/5.7/en/aggregate-functions.html p.�&~ � c��q0 �-}
� $ # % �tE� 6z� /�
infimum supremumD ��@ 1 � "� 6�ANY_VALUE %ANY_VALUE(arg)
This function is useful for GROUP BY queries when the
ONLY_FULL_GROUP_BY SQL mode is enabled, for cases when MySQL rejects a
query that you know is valid for reasons that MySQL cannot determine.
The function return value and type are the same as the return value and
type of its argument, but the function result is not checked for the
ONLY_FULL_GROUP_BY SQL mode.
For example, if name is a nonindexed column, the following query fails
with ONLY_FULL_GROUP_BY enabled:
mysql> SELECT name, address, MAX(age) FROM t GROUP BY name;
ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP
BY clause and contains nonaggregated column 'mydb.t.address' which
is not functionally dependent on columns in GROUP BY clause; this
is incompatible with sql_mode=only_full_group_by
The failure occurs because address is a nonaggregated column that is
neither named among GROUP BY columns nor functionally dependent on
them. As a result, the address value for rows within each name group is
nondeterministic. There are multiple ways to cause MySQL to accept the
query:
o Alter the table to make name a primary key or a unique NOT NULL
column. This enables MySQL to determine that address is functionally
dependent on name; that is, address is uniquely determined by name.
(This technique is inapplicable if NULL must be permitted as a valid
name value.)
o Use ANY_VALUE() to refer to address:
SELECT name, ANY_VALUE(address), MAX(age) FROM t GROUP BY name;
In this case, MySQL ignores the nondeterminism of address values
within each name group and accepts the query. This may be useful if
you simply do not care which value of a nonaggregated column is
chosen for each group. ANY_VALUE() is not an aggregate function,
unlike functions such as SUM() or COUNT(). It simply acts to suppress
the test for nondeterminism.
o Disable ONLY_FULL_GROUP_BY. This is equivalent to using ANY_VALUE()
with ONLY_FULL_GROUP_BY enabled, as described in the previous item.
ANY_VALUE() is also useful if functional dependence exists between
columns but MySQL cannot determine it. The following query is valid
because age is functionally dependent on the grouping column age-1, but
MySQL cannot tell that and rejects the query with ONLY_FULL_GROUP_BY
enabled:
SELECT age FROM t GROUP BY age-1;
To cause MySQL to accept the query, use ANY_VALUE():
SELECT ANY_VALUE(age) FROM t GROUP BY age-1;
ANY_VALUE() can be used for queries that refer to aggregate functions
in the absence of a GROUP BY clause:
mysql> SELECT name, MAX(age) FROM t;
ERROR 1140 (42000): In aggregated query without GROUP BY, expression
#1 of SELECT list contains nonaggregated column 'mydb.t.name'; this
is incompatible with sql_mode=only_full_group_by
Without GROUP BY, there is a single group and it is nondeterministic
which name value to choose for the group. ANY_VALUE() tells MySQL to
accept the query:
SELECT ANY_VALUE(name), MAX(age) FROM t;
It may be that, due to some property of a given data set, you know that
a selected nonaggregated column is effectively functionally dependent
on a GROUP BY column. For example, an application may enforce
uniqueness of one column with respect to another. In this case, using
ANY_VALUE() for the effectively functionally dependent column may make
sense.
For additional discussion, see
https://dev.mysql.com/doc/refman/5.7/en/group-by-handling.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD5ʀ@ � � "� 6�DEFAULT %Syntax:
DEFAULT(col_name)
Returns the default value for a table column. An error results if the
column has no default value.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD:[�@ 6 � "� 6�INET_ATON %Syntax:
INET_ATON(expr)
Given the dotted-quad representation of an IPv4 network address as a
string, returns an integer that represents the numeric value of the
address in network byte order (big endian). INET_ATON() returns NULL if
it does not understand its argument.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT INET_ATON('10.0.5.9');
-> 167773449
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD:L�@ (( � "� 6�INET_NTOA %Syntax:
INET_NTOA(expr)
Given a numeric IPv4 network address in network byte order, returns the
dotted-quad string representation of the address as a string in the
connection character set. INET_NTOA() returns NULL if it does not
understand its argument.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT INET_NTOA(167773449);
-> '10.0.5.9'
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD��1�@ 0~ � "� 6�INET6_ATON %Syntax:
INET6_ATON(expr)
Given an IPv6 or IPv4 network address as a string, returns a binary
string that represents the numeric value of the address in network byte
order (big endian). Because numeric-format IPv6 addresses require more
bytes than the largest integer type, the representation returned by
this function has the VARBINARY data type: VARBINARY(16) for IPv6
addresses and VARBINARY(4) for IPv4 addresses. If the argument is not a
valid address, INET6_ATON() returns NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT HEX(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
-> 'FDFE0000000000005A55CAFFFEFA9089'
mysql> SELECT HEX(INET6_ATON('10.0.5.9'));
-> '0A000509'
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlDb�5�@ 88 � "� 6�INET6_NTOA %Syntax:
INET6_NTOA(expr)
Given an IPv6 or IPv4 network address represented in numeric form as a
binary string, returns the string representation of the address as a
string in the connection character set. If the argument is not a valid
address, INET6_NTOA() returns NULL.
INET6_NTOA() has these properties:
o It does not use operating system functions to perform conversions,
thus the output string is platform independent.
o The return string has a maximum length of 39 (4 x 8 + 7). Given this
statement:
CREATE TABLE t AS SELECT INET6_NTOA(expr) AS c1;
The resulting table would have this definition:
CREATE TABLE t (c1 VARCHAR(39) CHARACTER SET utf8 DEFAULT NULL);
o The return string uses lowercase letters for IPv6 addresses.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT INET6_NTOA(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
-> 'fdfe::5a55:caff:fefa:9089'
mysql> SELECT INET6_NTOA(INET6_ATON('10.0.5.9'));
-> '10.0.5.9'
mysql> SELECT INET6_NTOA(UNHEX('FDFE0000000000005A55CAFFFEFA9089'));
-> 'fdfe::5a55:caff:fefa:9089'
mysql> SELECT INET6_NTOA(UNHEX('0A000509'));
-> '10.0.5.9'
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlDJ��@ @� � "� 6�IS_IPV4 %Syntax:
IS_IPV4(expr)
Returns 1 if the argument is a valid IPv4 address specified as a
string, 0 otherwise.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT IS_IPV4('10.0.5.9'), IS_IPV4('10.0.5.256');
-> 1, 0
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD��f�@ H� � "� 6�IS_IPV4_COMPAT %Syntax:
IS_IPV4_COMPAT(expr)
This function takes an IPv6 address represented in numeric form as a
binary string, as returned by INET6_ATON(). It returns 1 if the
argument is a valid IPv4-compatible IPv6 address, 0 otherwise.
IPv4-compatible addresses have the form ::ipv4_address.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT IS_IPV4_COMPAT(INET6_ATON('::10.0.5.9'));
-> 1
mysql> SELECT IS_IPV4_COMPAT(INET6_ATON('::ffff:10.0.5.9'));
-> 0
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD��c�@ P� � "� 6�IS_IPV4_MAPPED %Syntax:
IS_IPV4_MAPPED(expr)
This function takes an IPv6 address represented in numeric form as a
binary string, as returned by INET6_ATON(). It returns 1 if the
argument is a valid IPv4-mapped IPv6 address, 0 otherwise. IPv4-mapped
addresses have the form ::ffff:ipv4_address.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT IS_IPV4_MAPPED(INET6_ATON('::10.0.5.9'));
-> 0
mysql> SELECT IS_IPV4_MAPPED(INET6_ATON('::ffff:10.0.5.9'));
-> 1
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlDC�@ X� � "� 6 IS_IPV6 %Syntax:
IS_IPV6(expr)
Returns 1 if the argument is a valid IPv6 address specified as a
string, 0 otherwise. This function does not consider IPv4 addresses to
be valid IPv6 addresses.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT IS_IPV6('10.0.5.9'), IS_IPV6('::1');
-> 0, 1
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD (�@ `� � "� 6MASTER_POS_WAIT %Syntax:
MASTER_POS_WAIT(log_name,log_pos[,timeout][,channel])
This function is useful for control of source-replica synchronization.
It blocks until the replica has read and applied all updates up to the
specified position in the source log. The return value is the number of
log events the replica had to wait for to advance to the specified
position. The function returns NULL if the replica SQL thread is not
started, the replica's source information is not initialized, the
arguments are incorrect, or an error occurs. It returns -1 if the
timeout has been exceeded. If the replica SQL thread stops while
MASTER_POS_WAIT() is waiting, the function returns NULL. If the replica
is past the specified position, the function returns immediately.
On a multithreaded replica, the function waits until expiry of the
limit set by the slave_checkpoint_group or slave_checkpoint_period
system variable, when the checkpoint operation is called to update the
status of the replica. Depending on the setting for the system
variables, the function might therefore return some time after the
specified position was reached.
If a timeout value is specified, MASTER_POS_WAIT() stops waiting when
timeout seconds have elapsed. timeout must be greater than or equal to
0. (As of MySQL 5.7.18, when the server is running in strict SQL mode,
a negative timeout value is immediately rejected with
ER_WRONG_ARGUMENTS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_wrong_arguments); otherwise the function returns NULL, and
raises a warning.)
The optional channel value enables you to name which replication
channel the function applies to. See
https://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD i�@ h
� "� 6#NAME_CONST %Syntax:
NAME_CONST(name,value)
Returns the given value. When used to produce a result set column,
NAME_CONST() causes the column to have the given name. The arguments
should be constants.
mysql> SELECT NAME_CONST('myname', 14);
+--------+
| myname |
+--------+
| 14 |
+--------+
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD �@ p� � "� 60SLEEP %Syntax:
SLEEP(duration)
Sleeps (pauses) for the number of seconds given by the duration
argument, then returns 0. The duration may have a fractional part. If
the argument is NULL or negative, SLEEP() produces a warning, or an
error in strict SQL mode.
When sleep returns normally (without interruption), it returns 0:
mysql> SELECT SLEEP(1000);
+-------------+
| SLEEP(1000) |
+-------------+
| 0 |
+-------------+
When SLEEP() is the only thing invoked by a query that is interrupted,
it returns 1 and the query itself returns no error. This is true
whether the query is killed or times out:
o This statement is interrupted using KILL QUERY from another session:
mysql> SELECT SLEEP(1000);
+-------------+
| SLEEP(1000) |
+-------------+
| 1 |
+-------------+
o This statement is interrupted by timing out:
mysql> SELECT /*+ MAX_EXECUTION_TIME(1) */ SLEEP(1000);
+-------------+
| SLEEP(1000) |
+-------------+
| 1 |
+-------------+
When SLEEP() is only part of a query that is interrupted, the query
returns an error:
o This statement is interrupted using KILL QUERY from another session:
mysql> SELECT 1 FROM t1 WHERE SLEEP(1000);
ERROR 1317 (70100): Query execution was interrupted
o This statement is interrupted by timing out:
mysql> SELECT /*+ MAX_EXECUTION_TIME(1000) */ 1 FROM t1 WHERE SLEEP(1000);
ERROR 3024 (HY000): Query execution was interrupted, maximum statement
execution time exceeded
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html p � c}
� �t~۩" % $ & +�E� 7Y� 3 infimum supremumDH �@ � � "� 6=UUID %Syntax:
UUID()
Returns a Universal Unique Identifier (UUID) generated according to RFC
4122, "A Universally Unique IDentifier (UUID) URN Namespace"
(http://www.ietf.org/rfc/rfc4122.txt).
A UUID is designed as a number that is globally unique in space and
time. Two calls to UUID() are expected to generate two different
values, even if these calls are performed on two separate devices not
connected to each other.
*Warning*:
Although UUID() values are intended to be unique, they are not
necessarily unguessable or unpredictable. If unpredictability is
required, UUID values should be generated some other way.
UUID() returns a value that conforms to UUID version 1 as described in
RFC 4122. The value is a 128-bit number represented as a utf8 string of
five hexadecimal numbers in aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
format:
o The first three numbers are generated from the low, middle, and high
parts of a timestamp. The high part also includes the UUID version
number.
o The fourth number preserves temporal uniqueness in case the timestamp
value loses monotonicity (for example, due to daylight saving time).
o The fifth number is an IEEE 802 node number that provides spatial
uniqueness. A random number is substituted if the latter is not
available (for example, because the host device has no Ethernet card,
or it is unknown how to find the hardware address of an interface on
the host operating system). In this case, spatial uniqueness cannot
be guaranteed. Nevertheless, a collision should have very low
probability.
The MAC address of an interface is taken into account only on
FreeBSD, Linux, and Windows. On other operating systems, MySQL uses a
randomly generated 48-bit number.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT UUID();
-> '6ccd780c-baba-1026-9564-5b8c656024db'
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlD9l�@ F � "� 6JUUID_SHORT %Syntax:
UUID_SHORT()
Returns a "short" universal identifier as a 64-bit unsigned integer.
Values returned by UUID_SHORT() differ from the string-format 128-bit
identifiers returned by the UUID() function and have different
uniqueness properties. The value of UUID_SHORT() is guaranteed to be
unique if the following conditions hold:
o The server_id value of the current server is between 0 and 255 and is
unique among your set of source and replica servers
o You do not set back the system time for your server host between
mysqld restarts
o You invoke UUID_SHORT() on average fewer than 16 million times per
second between mysqld restarts
The UUID_SHORT() return value is constructed this way:
(server_id & 255) << 56
+ (server_startup_time_in_seconds << 24)
+ incremented_variable++;
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT UUID_SHORT();
-> 92395783831158784
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlDn��@ � � "� 6WVALUES %Syntax:
VALUES(col_name)
In an INSERT ... ON DUPLICATE KEY UPDATE statement, you can use the
VALUES(col_name) function in the UPDATE clause to refer to column
values from the INSERT portion of the statement. In other words,
VALUES(col_name) in the UPDATE clause refers to the value of col_name
that would be inserted, had no duplicate-key conflict occurred. This
function is especially useful in multiple-row inserts. The VALUES()
function is meaningful only in the ON DUPLICATE KEY UPDATE clause of
INSERT statements and returns NULL otherwise. See
https://dev.mysql.com/doc/refman/5.7/en/insert-on-duplicate.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
-> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);
https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html; n�@ ( � "� 6dALTER DATABASE &Syntax:
ALTER {DATABASE | SCHEMA} [db_name]
alter_option ...
ALTER {DATABASE | SCHEMA} db_name
UPGRADE DATA DIRECTORY NAME
alter_option: {
[DEFAULT] CHARACTER SET [=] charset_name
| [DEFAULT] COLLATE [=] collation_name
}
ALTER DATABASE enables you to change the overall characteristics of a
database. These characteristics are stored in the db.opt file in the
database directory. This statement requires the ALTER privilege on the
database. ALTER SCHEMA is a synonym for ALTER DATABASE.
The database name can be omitted from the first syntax, in which case
the statement applies to the default database. An error occurs if there
is no default database.
o https://dev.mysql.com/doc/refman/5.7/en/alter-database.html#alter-dat
abase-charset
o https://dev.mysql.com/doc/refman/5.7/en/alter-database.html#alter-dat
abase-upgrading
Character Set and Collation Options
The CHARACTER SET clause changes the default database character set.
The COLLATE clause changes the default database collation. For
information about character set and collation names, see
https://dev.mysql.com/doc/refman/5.7/en/charset.html.
To see the available character sets and collations, use the SHOW
CHARACTER SET and SHOW COLLATION statements, respectively. See [HELP
SHOW CHARACTER SET], and [HELP SHOW COLLATION].
A stored routine that uses the database defaults when the routine is
created includes those defaults as part of its definition. (In a stored
routine, variables with character data types use the database defaults
if the character set or collation are not specified explicitly. See
[HELP CREATE PROCEDURE].) If you change the default character set or
collation for a database, any stored routines that are to use the new
defaults must be dropped and recreated.
Upgrading from Versions Older than MySQL 5.1
The syntax that includes the UPGRADE DATA DIRECTORY NAME clause updates
the name of the directory associated with the database to use the
encoding implemented in MySQL 5.1 for mapping database names to
database directory names (see
https://dev.mysql.com/doc/refman/5.7/en/identifier-mapping.html). This
clause is for use under these conditions:
o It is intended when upgrading MySQL to 5.1 or later from older
versions.
o It is intended to update a database directory name to the current
encoding format if the name contains special characters that need
encoding.
o The statement is used by mysqlcheck (as invoked by mysql_upgrade).
For example, if a database in MySQL 5.0 has the name a-b-c, the name
contains instances of the - (dash) character. In MySQL 5.0, the
database directory is also named a-b-c, which is not necessarily safe
for all file systems. In MySQL 5.1 and later, the same database name is
encoded as a@002db@002dc to produce a file system-neutral directory
name.
When a MySQL installation is upgraded to MySQL 5.1 or later from an
older version,the server displays a name such as a-b-c (which is in the
old format) as #mysql50#a-b-c, and you must refer to the name using the
#mysql50# prefix. Use UPGRADE DATA DIRECTORY NAME in this case to
explicitly tell the server to re-encode the database directory name to
the current encoding format:
ALTER DATABASE `#mysql50#a-b-c` UPGRADE DATA DIRECTORY NAME;
After executing this statement, you can refer to the database as a-b-c
without the special #mysql50# prefix.
*Note*:
The UPGRADE DATA DIRECTORY NAME clause is deprecated in MySQL 5.7 and
removed in MySQL 8.0. If it is necessary to convert MySQL 5.0 database
or table names, a workaround is to upgrade a MySQL 5.0 installation to
MySQL 5.1 before upgrading to MySQL 8.0.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-database.html
https://dev.mysql.com/doc/refman/5.7/en/alter-database.html; n�@ 0 � "� 6qALTER SCHEMA &Syntax:
ALTER {DATABASE | SCHEMA} [db_name]
alter_option ...
ALTER {DATABASE | SCHEMA} db_name
UPGRADE DATA DIRECTORY NAME
alter_option: {
[DEFAULT] CHARACTER SET [=] charset_name
| [DEFAULT] COLLATE [=] collation_name
}
ALTER DATABASE enables you to change the overall characteristics of a
database. These characteristics are stored in the db.opt file in the
database directory. This statement requires the ALTER privilege on the
database. ALTER SCHEMA is a synonym for ALTER DATABASE.
The database name can be omitted from the first syntax, in which case
the statement applies to the default database. An error occurs if there
is no default database.
o https://dev.mysql.com/doc/refman/5.7/en/alter-database.html#alter-dat
abase-charset
o https://dev.mysql.com/doc/refman/5.7/en/alter-database.html#alter-dat
abase-upgrading
Character Set and Collation Options
The CHARACTER SET clause changes the default database character set.
The COLLATE clause changes the default database collation. For
information about character set and collation names, see
https://dev.mysql.com/doc/refman/5.7/en/charset.html.
To see the available character sets and collations, use the SHOW
CHARACTER SET and SHOW COLLATION statements, respectively. See [HELP
SHOW CHARACTER SET], and [HELP SHOW COLLATION].
A stored routine that uses the database defaults when the routine is
created includes those defaults as part of its definition. (In a stored
routine, variables with character data types use the database defaults
if the character set or collation are not specified explicitly. See
[HELP CREATE PROCEDURE].) If you change the default character set or
collation for a database, any stored routines that are to use the new
defaults must be dropped and recreated.
Upgrading from Versions Older than MySQL 5.1
The syntax that includes the UPGRADE DATA DIRECTORY NAME clause updates
the name of the directory associated with the database to use the
encoding implemented in MySQL 5.1 for mapping database names to
database directory names (see
https://dev.mysql.com/doc/refman/5.7/en/identifier-mapping.html). This
clause is for use under these conditions:
o It is intended when upgrading MySQL to 5.1 or later from older
versions.
o It is intended to update a database directory name to the current
encoding format if the name contains special characters that need
encoding.
o The statement is used by mysqlcheck (as invoked by mysql_upgrade).
For example, if a database in MySQL 5.0 has the name a-b-c, the name
contains instances of the - (dash) character. In MySQL 5.0, the
database directory is also named a-b-c, which is not necessarily safe
for all file systems. In MySQL 5.1 and later, the same database name is
encoded as a@002db@002dc to produce a file system-neutral directory
name.
When a MySQL installation is upgraded to MySQL 5.1 or later from an
older version,the server displays a name such as a-b-c (which is in the
old format) as #mysql50#a-b-c, and you must refer to the name using the
#mysql50# prefix. Use UPGRADE DATA DIRECTORY NAME in this case to
explicitly tell the server to re-encode the database directory name to
the current encoding format:
ALTER DATABASE `#mysql50#a-b-c` UPGRADE DATA DIRECTORY NAME;
After executing this statement, you can refer to the database as a-b-c
without the special #mysql50# prefix.
*Note*:
The UPGRADE DATA DIRECTORY NAME clause is deprecated in MySQL 5.7 and
removed in MySQL 8.0. If it is necessary to convert MySQL 5.0 database
or table names, a workaround is to upgrade a MySQL 5.0 installation to
MySQL 5.1 before upgrading to MySQL 8.0.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-database.html
https://dev.mysql.com/doc/refman/5.7/en/alter-database.html8 ��@ 8� � "� 6~ALTER EVENT &Syntax:
ALTER
[DEFINER = user]
EVENT event_name
[ON SCHEDULE schedule]
[ON COMPLETION [NOT] PRESERVE]
[RENAME TO new_event_name]
[ENABLE | DISABLE | DISABLE ON SLAVE]
[COMMENT 'string']
[DO event_body]
The ALTER EVENT statement changes one or more of the characteristics of
an existing event without the need to drop and recreate it. The syntax
for each of the DEFINER, ON SCHEDULE, ON COMPLETION, COMMENT, ENABLE /
DISABLE, and DO clauses is exactly the same as when used with CREATE
EVENT. (See [HELP CREATE EVENT].)
Any user can alter an event defined on a database for which that user
has the EVENT privilege. When a user executes a successful ALTER EVENT
statement, that user becomes the definer for the affected event.
ALTER EVENT works only with an existing event:
mysql> ALTER EVENT no_such_event
> ON SCHEDULE
> EVERY '2:3' DAY_HOUR;
ERROR 1517 (HY000): Unknown event 'no_such_event'
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-event.html
https://dev.mysql.com/doc/refman/5.7/en/alter-event.html; ��@ @�W � "� 6�ALTER FUNCTION &Syntax:
ALTER FUNCTION func_name [characteristic ...]
characteristic: {
COMMENT 'string'
| LANGUAGE SQL
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
}
This statement can be used to change the characteristics of a stored
function. More than one change may be specified in an ALTER FUNCTION
statement. However, you cannot change the parameters or body of a
stored function using this statement; to make such changes, you must
drop and re-create the function using DROP FUNCTION and CREATE
FUNCTION.
You must have the ALTER ROUTINE privilege for the function. (That
privilege is granted automatically to the function creator.) If binary
logging is enabled, the ALTER FUNCTION statement might also require the
SUPER privilege, as described in
https://dev.mysql.com/doc/refman/5.7/en/stored-programs-logging.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-function.html
https://dev.mysql.com/doc/refman/5.7/en/alter-function.html p c~۩" +��_ & % ' ��E� ;� 8� infimum supremum; >�@ � � "� 6�ALTER INSTANCE &Syntax:
ALTER INSTANCE ROTATE INNODB MASTER KEY
ALTER INSTANCE, introduced in MySQL 5.7.11, defines actions applicable
to a MySQL server instance. The statement supports these actions:
o ALTER INSTANCE ROTATE INNODB MASTER KEY
This action rotates the master encryption key used for InnoDB
tablespace encryption. Key rotation requires the SUPER privilege. To
perform this action, a keyring plugin must be installed and
configured. For instructions, see
https://dev.mysql.com/doc/refman/5.7/en/keyring.html.
ALTER INSTANCE ROTATE INNODB MASTER KEY supports concurrent DML.
However, it cannot be run concurrently with CREATE TABLE ...
ENCRYPTION or ALTER TABLE ... ENCRYPTION operations, and locks are
taken to prevent conflicts that could arise from concurrent execution
of these statements. If one of the conflicting statements is running,
it must complete before another can proceed.
ALTER INSTANCE actions are written to the binary log so that they can
be executed on replicated servers.
For additional ALTER INSTANCE ROTATE INNODB MASTER KEY usage
information, see
https://dev.mysql.com/doc/refman/5.7/en/innodb-data-encryption.html.
For information about keyring plugins, see
https://dev.mysql.com/doc/refman/5.7/en/keyring.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-instance.html
https://dev.mysql.com/doc/refman/5.7/en/alter-instance.html@ ��@ F � "� 6�ALTER LOGFILE GROUP &Syntax:
ALTER LOGFILE GROUP logfile_group
ADD UNDOFILE 'file_name'
[INITIAL_SIZE [=] size]
[WAIT]
ENGINE [=] engine_name
This statement adds an UNDO file named 'file_name' to an existing log
file group logfile_group. An ALTER LOGFILE GROUP statement has one and
only one ADD UNDOFILE clause. No DROP UNDOFILE clause is currently
supported.
*Note*:
All NDB Cluster Disk Data objects share the same namespace. This means
that each Disk Data object must be uniquely named (and not merely each
Disk Data object of a given type). For example, you cannot have a
tablespace and an undo log file with the same name, or an undo log file
and a data file with the same name.
The optional INITIAL_SIZE parameter sets the UNDO file's initial size
in bytes; if not specified, the initial size defaults to 134217728 (128
MB). You may optionally follow size with a one-letter abbreviation for
an order of magnitude, similar to those used in my.cnf. Generally, this
is one of the letters M (megabytes) or G (gigabytes). (Bug #13116514,
Bug #16104705, Bug #62858)
On 32-bit systems, the maximum supported value for INITIAL_SIZE is
4294967296 (4 GB). (Bug #29186)
The minimum allowed value for INITIAL_SIZE is 1048576 (1 MB). (Bug
#29574)
*Note*:
WAIT is parsed but otherwise ignored. This keyword currently has no
effect, and is intended for future expansion.
The ENGINE parameter (required) determines the storage engine which is
used by this log file group, with engine_name being the name of the
storage engine. Currently, the only accepted values for engine_name are
"NDBCLUSTER" and "NDB". The two values are equivalent.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-logfile-group.html
https://dev.mysql.com/doc/refman/5.7/en/alter-logfile-group.html< ��@ K � "� 6�ALTER PROCEDURE &Syntax:
ALTER PROCEDURE proc_name [characteristic ...]
characteristic: {
COMMENT 'string'
| LANGUAGE SQL
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
}
This statement can be used to change the characteristics of a stored
procedure. More than one change may be specified in an ALTER PROCEDURE
statement. However, you cannot change the parameters or body of a
stored procedure using this statement; to make such changes, you must
drop and re-create the procedure using DROP PROCEDURE and CREATE
PROCEDURE.
You must have the ALTER ROUTINE privilege for the procedure. By
default, that privilege is granted automatically to the procedure
creator. This behavior can be changed by disabling the
automatic_sp_privileges system variable. See
https://dev.mysql.com/doc/refman/5.7/en/stored-routines-privileges.html
.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-procedure.html
https://dev.mysql.com/doc/refman/5.7/en/alter-procedure.html9'x�@ (5 � "� 6�ALTER SERVER &Syntax:
ALTER SERVER server_name
OPTIONS (option [, option] ...)
Alters the server information for server_name, adjusting any of the
options permitted in the CREATE SERVER statement. The corresponding
fields in the mysql.servers table are updated accordingly. This
statement requires the SUPER privilege.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-server.html
ALTER SERVER s OPTIONS (USER 'sally');
https://dev.mysql.com/doc/refman/5.7/en/alter-server.html8 ��@ 0 � "� 6�ALTER TABLE &Syntax:
ALTER TABLE tbl_name
[alter_option [, alter_option] ...]
[partition_options]
alter_option: {
table_options
| ADD [COLUMN] col_name column_definition
[FIRST | AFTER col_name]
| ADD [COLUMN] (col_name column_definition,...)
| ADD {INDEX | KEY} [index_name]
[index_type] (key_part,...) [index_option] ...
| ADD {FULLTEXT | SPATIAL} [INDEX | KEY] [index_name]
(key_part,...) [index_option] ...
| ADD [CONSTRAINT [symbol]] PRIMARY KEY
[index_type] (key_part,...)
[index_option] ...
| ADD [CONSTRAINT [symbol]] UNIQUE [INDEX | KEY]
[index_name] [index_type] (key_part,...)
[index_option] ...
| ADD [CONSTRAINT [symbol]] FOREIGN KEY
[index_name] (col_name,...)
reference_definition
| ADD CHECK (expr)
| ALGORITHM [=] {DEFAULT | INPLACE | COPY}
| ALTER [COLUMN] col_name {
SET DEFAULT {literal | (expr)}
| DROP DEFAULT
}
| CHANGE [COLUMN] old_col_name new_col_name column_definition
[FIRST | AFTER col_name]
| [DEFAULT] CHARACTER SET [=] charset_name [COLLATE [=] collation_name]
| CONVERT TO CHARACTER SET charset_name [COLLATE collation_name]
| {DISABLE | ENABLE} KEYS
| {DISCARD | IMPORT} TABLESPACE
| DROP [COLUMN] col_name
| DROP {INDEX | KEY} index_name
| DROP PRIMARY KEY
| DROP FOREIGN KEY fk_symbol
| FORCE
| LOCK [=] {DEFAULT | NONE | SHARED | EXCLUSIVE}
| MODIFY [COLUMN] col_name column_definition
[FIRST | AFTER col_name]
| ORDER BY col_name [, col_name] ...
| RENAME {INDEX | KEY} old_index_name TO new_index_name
| RENAME [TO | AS] new_tbl_name
| {WITHOUT | WITH} VALIDATION
}
partition_options:
partition_option [partition_option] ...
partition_option: {
ADD PARTITION (partition_definition)
| DROP PARTITION partition_names
| DISCARD PARTITION {partition_names | ALL} TABLESPACE
| IMPORT PARTITION {partition_names | ALL} TABLESPACE
| TRUNCATE PARTITION {partition_names | ALL}
| COALESCE PARTITION number
| REORGANIZE PARTITION partition_names INTO (partition_definitions)
| EXCHANGE PARTITION partition_name WITH TABLE tbl_name [{WITH | WITHOUT} VALIDATION]
| ANALYZE PARTITION {partition_names | ALL}
| CHECK PARTITION {partition_names | ALL}
| OPTIMIZE PARTITION {partition_names | ALL}
| REBUILD PARTITION {partition_names | ALL}
| REPAIR PARTITION {partition_names | ALL}
| REMOVE PARTITIONING
| UPGRADE PARTITIONING
}
key_part:
col_name [(length)] [ASC | DESC]
index_type:
USING {BTREE | HASH}
index_option: {
KEY_BLOCK_SIZE [=] value
| index_type
| WITH PARSER parser_name
| COMMENT 'string'
}
table_options:
table_option [[,] table_option] ...
table_option: {
AUTO_INCREMENT [=] value
| AVG_ROW_LENGTH [=] value
| [DEFAULT] CHARACTER SET [=] charset_name
| CHECKSUM [=] {0 | 1}
| [DEFAULT] COLLATE [=] collation_name
| COMMENT [=] 'string'
| COMPRESSION [=] {'ZLIB' | 'LZ4' | 'NONE'}
| CONNECTION [=] 'connect_string'
| {DATA | INDEX} DIRECTORY [=] 'absolute path to directory'
| DELAY_KEY_WRITE [=] {0 | 1}
| ENCRYPTION [=] {'Y' | 'N'}
| ENGINE [=] engine_name
| INSERT_METHOD [=] { NO | FIRST | LAST }
| KEY_BLOCK_SIZE [=] value
| MAX_ROWS [=] value
| MIN_ROWS [=] value
| PACK_KEYS [=] {0 | 1 | DEFAULT}
| PASSWORD [=] 'string'
| ROW_FORMAT [=] {DEFAULT | DYNAMIC | FIXED | COMPRESSED | REDUNDANT | COMPACT}
| STATS_AUTO_RECALC [=] {DEFAULT | 0 | 1}
| STATS_PERSISTENT [=] {DEFAULT | 0 | 1}
| STATS_SAMPLE_PAGES [=] value
| TABLESPACE tablespace_name [STORAGE {DISK | MEMORY}]
| UNION [=] (tbl_name[,tbl_name]...)
}
partition_options:
(see CREATE TABLE options)
ALTER TABLE changes the structure of a table. For example, you can add
or delete columns, create or destroy indexes, change the type of
existing columns, or rename columns or the table itself. You can also
change characteristics such as the storage engine used for the table or
the table comment.
o To use ALTER TABLE, you need ALTER, CREATE, and INSERT privileges for
the table. Renaming a table requires ALTER and DROP on the old table,
ALTER, CREATE, and INSERT on the new table.
o Following the table name, specify the alterations to be made. If none
are given, ALTER TABLE does nothing.
o The syntax for many of the permissible alterations is similar to
clauses of the CREATE TABLE statement. column_definition clauses use
the same syntax for ADD and CHANGE as for CREATE TABLE. For more
information, see [HELP CREATE TABLE].
o The word COLUMN is optional and can be omitted.
o Multiple ADD, ALTER, DROP, and CHANGE clauses are permitted in a
single ALTER TABLE statement, separated by commas. This is a MySQL
extension to standard SQL, which permits only one of each clause per
ALTER TABLE statement. For example, to drop multiple columns in a
single statement, do this:
ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;
o If a storage engine does not support an attempted ALTER TABLE
operation, a warning may result. Such warnings can be displayed with
SHOW WARNINGS. See [HELP SHOW WARNINGS]. For information on
troubleshooting ALTER TABLE, see
https://dev.mysql.com/doc/refman/5.7/en/alter-table-problems.html.
o For information about generated columns, see
https://dev.mysql.com/doc/refman/5.7/en/alter-table-generated-columns
.html.
o For usage examples, see
https://dev.mysql.com/doc/refman/5.7/en/alter-table-examples.html.
o With the mysql_info()
(https://dev.mysql.com/doc/c-api/5.7/en/mysql-info.html) C API
function, you can find out how many rows were copied by ALTER TABLE.
See mysql_info()
(https://dev.mysql.com/doc/c-api/5.7/en/mysql-info.html).
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-table.html
https://dev.mysql.com/doc/refman/5.7/en/alter-table.html= �@ 8
� � "� 6�ALTER TABLESPACE &Syntax:
ALTER TABLESPACE tablespace_name
{ADD | DROP} DATAFILE 'file_name'
[INITIAL_SIZE [=] size]
[WAIT]
ENGINE [=] engine_name
This statement is used either to add a new data file, or to drop a data
file from a tablespace.
The ADD DATAFILE variant enables you to specify an initial size using
an INITIAL_SIZE clause, where size is measured in bytes; the default
value is 134217728 (128 MB). You may optionally follow size with a
one-letter abbreviation for an order of magnitude, similar to those
used in my.cnf. Generally, this is one of the letters M (megabytes) or
G (gigabytes).
*Note*:
All NDB Cluster Disk Data objects share the same namespace. This means
that each Disk Data object must be uniquely named (and not merely each
Disk Data object of a given type). For example, you cannot have a
tablespace and a data file with the same name, or an undo log file and
a tablespace with the same name.
On 32-bit systems, the maximum supported value for INITIAL_SIZE is
4294967296 (4 GB). (Bug #29186)
INITIAL_SIZE is rounded, explicitly, as for CREATE TABLESPACE.
Once a data file has been created, its size cannot be changed; however,
you can add more data files to the tablespace using additional ALTER
TABLESPACE ... ADD DATAFILE statements.
Using DROP DATAFILE with ALTER TABLESPACE drops the data file
'file_name' from the tablespace. You cannot drop a data file from a
tablespace which is in use by any table; in other words, the data file
must be empty (no extents used). See
https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data-objects
.html. In addition, any data file to be dropped must previously have
been added to the tablespace with CREATE TABLESPACE or ALTER
TABLESPACE.
Both ALTER TABLESPACE ... ADD DATAFILE and ALTER TABLESPACE ... DROP
DATAFILE require an ENGINE clause which specifies the storage engine
used by the tablespace. Currently, the only accepted values for
engine_name are NDB and NDBCLUSTER.
WAIT is parsed but otherwise ignored, and so has no effect in MySQL
5.7. It is intended for future expansion.
When ALTER TABLESPACE ... ADD DATAFILE is used with ENGINE = NDB, a
data file is created on each Cluster data node. You can verify that the
data files were created and obtain information about them by querying
the Information Schema FILES table. For example, the following query
shows all data files belonging to the tablespace named newts:
mysql> SELECT LOGFILE_GROUP_NAME, FILE_NAME, EXTRA
-> FROM INFORMATION_SCHEMA.FILES
-> WHERE TABLESPACE_NAME = 'newts' AND FILE_TYPE = 'DATAFILE';
+--------------------+--------------+----------------+
| LOGFILE_GROUP_NAME | FILE_NAME | EXTRA |
+--------------------+--------------+----------------+
| lg_3 | newdata.dat | CLUSTER_NODE=3 |
| lg_3 | newdata.dat | CLUSTER_NODE=4 |
| lg_3 | newdata2.dat | CLUSTER_NODE=3 |
| lg_3 | newdata2.dat | CLUSTER_NODE=4 |
+--------------------+--------------+----------------+
2 rows in set (0.03 sec)
See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-files-table.
html.
ALTER TABLESPACE is useful only with Disk Data storage for NDB Cluster.
See
https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-tablespace.html
https://dev.mysql.com/doc/refman/5.7/en/alter-tablespace.html7 ��@ @Ǚ � "� 6�ALTER VIEW &Syntax:
ALTER
[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
[DEFINER = user]
[SQL SECURITY { DEFINER | INVOKER }]
VIEW view_name [(column_list)]
AS select_statement
[WITH [CASCADED | LOCAL] CHECK OPTION]
This statement changes the definition of a view, which must exist. The
syntax is similar to that for CREATE VIEW see [HELP CREATE VIEW]). This
statement requires the CREATE VIEW and DROP privileges for the view,
and some privilege for each column referred to in the SELECT statement.
ALTER VIEW is permitted only to the definer or users with the SUPER
privilege.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-view.html
https://dev.mysql.com/doc/refman/5.7/en/alter-view.html p c��_ ��`�ӎ ' & B }NE� 2Ԁ
*� infimum supremum< ��@ @ � "� 6�CREATE DATABASE &Syntax:
CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
[create_option] ...
create_option: [DEFAULT] {
CHARACTER SET [=] charset_name
| COLLATE [=] collation_name
}
CREATE DATABASE creates a database with the given name. To use this
statement, you need the CREATE privilege for the database. CREATE
SCHEMA is a synonym for CREATE DATABASE.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-database.html
https://dev.mysql.com/doc/refman/5.7/en/create-database.html< ��@ @ � "� 6 CREATE SCHEMA &Syntax:
CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
[create_option] ...
create_option: [DEFAULT] {
CHARACTER SET [=] charset_name
| COLLATE [=] collation_name
}
CREATE DATABASE creates a database with the given name. To use this
statement, you need the CREATE privilege for the database. CREATE
SCHEMA is a synonym for CREATE DATABASE.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-database.html
https://dev.mysql.com/doc/refman/5.7/en/create-database.html9
�@
� � "� 6
CREATE EVENT &Syntax:
CREATE
[DEFINER = user]
EVENT
[IF NOT EXISTS]
event_name
ON SCHEDULE schedule
[ON COMPLETION [NOT] PRESERVE]
[ENABLE | DISABLE | DISABLE ON SLAVE]
[COMMENT 'string']
DO event_body;
schedule: {
AT timestamp [+ INTERVAL interval] ...
| EVERY interval
[STARTS timestamp [+ INTERVAL interval] ...]
[ENDS timestamp [+ INTERVAL interval] ...]
}
interval:
quantity {YEAR | QUARTER | MONTH | DAY | HOUR | MINUTE |
WEEK | SECOND | YEAR_MONTH | DAY_HOUR | DAY_MINUTE |
DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND}
This statement creates and schedules a new event. The event does not
run unless the Event Scheduler is enabled. For information about
checking Event Scheduler status and enabling it if necessary, see
https://dev.mysql.com/doc/refman/5.7/en/events-configuration.html.
CREATE EVENT requires the EVENT privilege for the schema in which the
event is to be created. If the DEFINER clause is present, the
privileges required depend on the user value, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-objects-security.html.
The minimum requirements for a valid CREATE EVENT statement are as
follows:
o The keywords CREATE EVENT plus an event name, which uniquely
identifies the event in a database schema.
o An ON SCHEDULE clause, which determines when and how often the event
executes.
o A DO clause, which contains the SQL statement to be executed by an
event.
This is an example of a minimal CREATE EVENT statement:
CREATE EVENT myevent
ON SCHEDULE AT CURRENT_TIMESTAMP + INTERVAL 1 HOUR
DO
UPDATE myschema.mytable SET mycol = mycol + 1;
The previous statement creates an event named myevent. This event
executes once---one hour following its creation---by running an SQL
statement that increments the value of the myschema.mytable table's
mycol column by 1.
The event_name must be a valid MySQL identifier with a maximum length
of 64 characters. Event names are not case-sensitive, so you cannot
have two events named myevent and MyEvent in the same schema. In
general, the rules governing event names are the same as those for
names of stored routines. See
https://dev.mysql.com/doc/refman/5.7/en/identifiers.html.
An event is associated with a schema. If no schema is indicated as part
of event_name, the default (current) schema is assumed. To create an
event in a specific schema, qualify the event name with a schema using
schema_name.event_name syntax.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-event.html
https://dev.mysql.com/doc/refman/5.7/en/create-event.html9 ��@ ( � "� 6 CREATE INDEX &Syntax:
CREATE [UNIQUE | FULLTEXT | SPATIAL] INDEX index_name
[index_type]
ON tbl_name (key_part,...)
[index_option]
[algorithm_option | lock_option] ...
key_part:
col_name [(length)] [ASC | DESC]
index_option: {
KEY_BLOCK_SIZE [=] value
| index_type
| WITH PARSER parser_name
| COMMENT 'string'
}
index_type:
USING {BTREE | HASH}
algorithm_option:
ALGORITHM [=] {DEFAULT | INPLACE | COPY}
lock_option:
LOCK [=] {DEFAULT | NONE | SHARED | EXCLUSIVE}
Normally, you create all indexes on a table at the time the table
itself is created with CREATE TABLE. See [HELP CREATE TABLE]. This
guideline is especially important for InnoDB tables, where the primary
key determines the physical layout of rows in the data file. CREATE
INDEX enables you to add indexes to existing tables.
CREATE INDEX is mapped to an ALTER TABLE statement to create indexes.
See [HELP ALTER TABLE]. CREATE INDEX cannot be used to create a PRIMARY
KEY; use ALTER TABLE instead. For more information about indexes, see
https://dev.mysql.com/doc/refman/5.7/en/mysql-indexes.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-index.html
https://dev.mysql.com/doc/refman/5.7/en/create-index.htmlA ͓@ 0k � "� 6 'CREATE LOGFILE GROUP &Syntax:
CREATE LOGFILE GROUP logfile_group
ADD UNDOFILE 'undo_file'
[INITIAL_SIZE [=] initial_size]
[UNDO_BUFFER_SIZE [=] undo_buffer_size]
[REDO_BUFFER_SIZE [=] redo_buffer_size]
[NODEGROUP [=] nodegroup_id]
[WAIT]
[COMMENT [=] 'string']
ENGINE [=] engine_name
This statement creates a new log file group named logfile_group having
a single UNDO file named 'undo_file'. A CREATE LOGFILE GROUP statement
has one and only one ADD UNDOFILE clause. For rules covering the naming
of log file groups, see
https://dev.mysql.com/doc/refman/5.7/en/identifiers.html.
*Note*:
All NDB Cluster Disk Data objects share the same namespace. This means
that each Disk Data object must be uniquely named (and not merely each
Disk Data object of a given type). For example, you cannot have a
tablespace and a log file group with the same name, or a tablespace and
a data file with the same name.
There can be only one log file group per NDB Cluster instance at any
given time.
The optional INITIAL_SIZE parameter sets the UNDO file's initial size;
if not specified, it defaults to 128M (128 megabytes). The optional
UNDO_BUFFER_SIZE parameter sets the size used by the UNDO buffer for
the log file group; The default value for UNDO_BUFFER_SIZE is 8M (eight
megabytes); this value cannot exceed the amount of system memory
available. Both of these parameters are specified in bytes. You may
optionally follow either or both of these with a one-letter
abbreviation for an order of magnitude, similar to those used in
my.cnf. Generally, this is one of the letters M (for megabytes) or G
(for gigabytes).
Memory used for UNDO_BUFFER_SIZE comes from the global pool whose size
is determined by the value of the SharedGlobalMemory data node
configuration parameter. This includes any default value implied for
this option by the setting of the InitialLogFileGroup data node
configuration parameter.
The maximum permitted for UNDO_BUFFER_SIZE is 629145600 (600 MB).
On 32-bit systems, the maximum supported value for INITIAL_SIZE is
4294967296 (4 GB). (Bug #29186)
The minimum allowed value for INITIAL_SIZE is 1048576 (1 MB).
The ENGINE option determines the storage engine to be used by this log
file group, with engine_name being the name of the storage engine. In
MySQL 5.7, this must be NDB (or NDBCLUSTER). If ENGINE is not set,
MySQL tries to use the engine specified by the default_storage_engine
server system variable (formerly storage_engine). In any case, if the
engine is not specified as NDB or NDBCLUSTER, the CREATE LOGFILE GROUP
statement appears to succeed but actually fails to create the log file
group, as shown here:
mysql> CREATE LOGFILE GROUP lg1
-> ADD UNDOFILE 'undo.dat' INITIAL_SIZE = 10M;
Query OK, 0 rows affected, 1 warning (0.00 sec)
mysql> SHOW WARNINGS;
+-------+------+------------------------------------------------------------------------------------------------+
| Level | Code | Message |
+-------+------+------------------------------------------------------------------------------------------------+
| Error | 1478 | Table storage engine 'InnoDB' does not support the create option 'TABLESPACE or LOGFILE GROUP' |
+-------+------+------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
mysql> DROP LOGFILE GROUP lg1 ENGINE = NDB;
ERROR 1529 (HY000): Failed to drop LOGFILE GROUP
mysql> CREATE LOGFILE GROUP lg1
-> ADD UNDOFILE 'undo.dat' INITIAL_SIZE = 10M
-> ENGINE = NDB;
Query OK, 0 rows affected (2.97 sec)
The fact that the CREATE LOGFILE GROUP statement does not actually
return an error when a non-NDB storage engine is named, but rather
appears to succeed, is a known issue which we hope to address in a
future release of NDB Cluster.
REDO_BUFFER_SIZE, NODEGROUP, WAIT, and COMMENT are parsed but ignored,
and so have no effect in MySQL 5.7. These options are intended for
future expansion.
When used with ENGINE [=] NDB, a log file group and associated UNDO log
file are created on each Cluster data node. You can verify that the
UNDO files were created and obtain information about them by querying
the Information Schema FILES table. For example:
mysql> SELECT LOGFILE_GROUP_NAME, LOGFILE_GROUP_NUMBER, EXTRA
-> FROM INFORMATION_SCHEMA.FILES
-> WHERE FILE_NAME = 'undo_10.dat';
+--------------------+----------------------+----------------+
| LOGFILE_GROUP_NAME | LOGFILE_GROUP_NUMBER | EXTRA |
+--------------------+----------------------+----------------+
| lg_3 | 11 | CLUSTER_NODE=3 |
| lg_3 | 11 | CLUSTER_NODE=4 |
+--------------------+----------------------+----------------+
2 rows in set (0.06 sec)
CREATE LOGFILE GROUP is useful only with Disk Data storage for NDB
Cluster. See
https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-logfile-group.html
https://dev.mysql.com/doc/refman/5.7/en/create-logfile-group.html= �@ 8 � � "� 6 4CREATE PROCEDURE & @ & (�https://dev.mysql.com/doc/refman/5.7/en/create-procedure.html= �@ @ � � "� 6 ACREATE FUNCTION & A & (�https://dev.mysql.com/doc/refman/5.7/en/create-procedure.html:lP�@ H�� � "� 6 NCREATE SERVER &Syntax:
CREATE SERVER server_name
FOREIGN DATA WRAPPER wrapper_name
OPTIONS (option [, option] ...)
option: {
HOST character-literal
| DATABASE character-literal
| USER character-literal
| PASSWORD character-literal
| SOCKET character-literal
| OWNER character-literal
| PORT numeric-literal
}
This statement creates the definition of a server for use with the
FEDERATED storage engine. The CREATE SERVER statement creates a new row
in the servers table in the mysql database. This statement requires the
SUPER privilege.
The server_name should be a unique reference to the server. Server
definitions are global within the scope of the server, it is not
possible to qualify the server definition to a specific database.
server_name has a maximum length of 64 characters (names longer than 64
characters are silently truncated), and is case-insensitive. You may
specify the name as a quoted string.
The wrapper_name is an identifier and may be quoted with single
quotation marks.
For each option you must specify either a character literal or numeric
literal. Character literals are UTF-8, support a maximum length of 64
characters and default to a blank (empty) string. String literals are
silently truncated to 64 characters. Numeric literals must be a number
between 0 and 9999, default value is 0.
*Note*:
The OWNER option is currently not applied, and has no effect on the
ownership or operation of the server connection that is created.
The CREATE SERVER statement creates an entry in the mysql.servers table
that can later be used with the CREATE TABLE statement when creating a
FEDERATED table. The options that you specify are used to populate the
columns in the mysql.servers table. The table columns are Server_name,
Host, Db, Username, Password, Port and Socket.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-server.html
CREATE SERVER s
FOREIGN DATA WRAPPER mysql
OPTIONS (USER 'Remote', HOST '198.51.100.106', DATABASE 'test');
https://dev.mysql.com/doc/refman/5.7/en/create-server.html p� c`�ӎ }N .� ( #��E� %� %~ � " infimum supremum@ JCREATE SERVER �@ JCREATE TABLE �@ JCREATE TABLESPACE �@ (!�CREATE TRIGGER �@ 0 JCREATE VIEW �@ 8 JCREATE_ASYMMETRIC_PRIV_KEY @ @ JCREATE_ASYMMETRIC_PUB_KEY
@ H JCREATE_DH_PARAMETERS @ P JCREATE_DIGEST @ X JCROSSES }@ ` JCURDATE ~@ h JCURRENT_DATE @ p JCURRENT_TIME �@ x JCURRENT_TIMESTAMP �@ � JCURRENT_USER @ � JCURTIME �@ � JDATABASE @ � JDATE @ � JDATE FUNCTION �@ � JDATEDIFF �@ � JDATETIME @ � JDATE_ADD �@ � JDATE_FORMAT �@ � JDATE_SUB �@ � JDAY �@ � JDAYNAME �@ � JDAYOFMONTH �@ � JDAYOFWEEK �@ ��DAYOFYEAR �@ � JDEC @ &DECIMAL @ JDECODE �@ JDEFAULT �@ JDEGREES h@ �DELETE @( JDES_DECRYPT �@ 0 JDES_ENCRYPT @ 8 JDIMENSION J@ @ JDISJOINT �@H JDISTANCE ~@ P JDIV [@ X JDO
@ ` JDOUBLE @h JDOUBLE PRECISION @ p JDROP DATABASE �@ x JDROP EVENT @ �BDROP FUNCTION @��DROP INDEX @ � JDROP PROCEDURE @ � JDROP SCHEMA �@ � JDROP SERVER @� JDROP TABLE @ � JDROP TABLESPACE @ ��DROP TRIGGER @ ��DROP VIEW @� JELT �@ � JENCODE @ � JENCRYPT @ � JENDPOINT Z@� JENUM 0@ � JENVELOPE K@ �*EQUALS �@ 6EXP i@ JEXPORT_SET �@ JEXTERIORRING h@ JEXTRACT �@ JEXTRACTVALUE �@(*FALSE @ 0 JFIELD �@ 8 JFIND_IN_SET �@ @ JFLOAT @HRFLOOR j@ P JFLUSH QUERY CACHE @ X JFOREIGN KEY �@ ` JFORMAT �@h JFOUND_ROWS @ p JFROM_BASE64 �@ x JFROM_DAYS �@ � JFROM_UNIXTIME �@� JGEOMCOLLFROMTEXT @ � JGEOMCOLLFROMWKB /@ � JGEOMETRY HIERARCHY 3@ � JGEOMETRYCOLLECTION ?@� JGEOMETRYN p@ � JGEOMETRYTYPE L@ � JGEOMFROMTEXT @ � �GEOMFROMWKB 0@� JGET_FORMAT �@ � JGET_LOCK @ � �GLENGTH [@ � JGREATEST B@� JGROUP_CONCAT �@ � JGTID_SUBSET �@ ��GTID_SUBTRACT �@ �HELP COMMAND @ JHELP_DATE @ JHELP_VERSION @ JHEX �@ JHOUR �@(VIF FUNCTION S@ 0 JIFNULL T@ 8 JIN C@ @ JINET6_ATON �@H JINET6_NTOA �@ P JINET_ATON �@ X �INET_NTOA �@ `��HANDLER @ h JINSERT @ p�INSERT DELAYED @ x�dDUAL @ �� EXECUTE STATEMENT /@ ��LDEALLOCATE PREPARE 0@ ��DROP PREPARE 1@ ��LDECLARE VARIABLE 4@ ���IF STATEMENT 6@ � �DECLARE CURSOR >@ �� FETCH ?@ ��lDECLARE CONDITION A@ ���DECLARE HANDLER B@ ��GET DIAGNOSTICS C@ ��xCREATE USER G@ ��DROP USER H@ �GRANT I@ ��DROP FUNCTION LOADABLE FUNCTION S@ ��FLUSH �@ ��EXPLAIN �@ �DESCRIBE �@ ��DESC �@ �vHELP STATEMENT � p D ���|T,���d< � �
� t *L$����\ c .� #��J��c ) ���� #�E� )/�� .� � " infimum supremum@ JSIGNAL E@ JSIN w@ JSLEEP �@ ( JSMALLINT @ 0 JSOUNDEX �@ 8 JSOUNDS LIKE �@ @ JSPACE �@ H JSPATIAL COLUMNS 6@ P JSPATIAL INDEXES 7@ X JSQRT x@ ` JSRID O@ h JSTART SLAVE ,@ p JSTART TRANSACTION @ x JSTARTPOINT e@ � JSTD �@ � JSTDDEV �@ � JSTDDEV_POP �@ � JSTDDEV_SAMP �@ � JSTOP SLAVE -@ � JSTRCMP �@ � JSTR_TO_DATE �@ � JST_AREA k@ � JST_ASBINARY H@ � JST_ASGEOJSON �@ � JST_ASTEXT I@ � JST_BUFFER v@ � JST_BUFFER_STRATEGY w@ � JST_CENTROID l@ � JST_CONTAINS @ � JST_CONVEXHULL x@ JST_CROSSES �@ JST_DIFFERENCE y@ JST_DIMENSION P@ JST_DISJOINT �@ JST_DISTANCE �@( JST_DISTANCE_SPHERE �@ 0 JST_ENDPOINT _@ 8 JST_ENVELOPE Q@ @ JST_EQUALS �@H JST_EXTERIORRING m@ P JST_GEOHASH �@ X JST_GEOMCOLLFROMTEXT '@ ` JST_GEOMCOLLFROMWKB 7@h JST_GEOMETRYN r@ p JST_GEOMETRYTYPE R@ x JST_GEOMFROMGEOJSON �@ � JST_GEOMFROMTEXT (@� JST_GEOMFROMWKB 8@ � JST_INTERIORRINGN n@ � JST_INTERSECTION z@ � JST_INTERSECTS �@� JST_ISCLOSED `@ � JST_ISEMPTY S@ � JST_ISSIMPLE T@ � JST_ISVALID �@� JST_LATFROMGEOHASH �@ � JST_LENGTH a@ � JST_LINEFROMTEXT )@ � JST_LINEFROMWKB 9@� JST_LONGFROMGEOHASH �@ � JST_MAKEENVELOPE �@ � JST_MLINEFROMTEXT *@ JST_MLINEFROMWKB :@ JST_MPOINTFROMTEXT +@ JST_MPOINTFROMWKB ;@ JST_MPOLYFROMTEXT ,@ JST_MPOLYFROMWKB <@( JST_NUMGEOMETRIES s@ 0 JST_NUMINTERIORRINGS o@ 8 JST_NUMPOINTS b@ @ JST_OVERLAPS �@H JST_POINTFROMGEOHASH �@ P JST_POINTFROMTEXT -@ X JST_POINTFROMWKB =@ ` JST_POINTN c@h JST_POLYFROMTEXT .@ p JST_POLYFROMWKB >@ x JST_SIMPLIFY �@ � JST_SRID U@� JST_STARTPOINT d@ � JST_SYMDIFFERENCE {@ � JST_TOUCHES �@ � JST_UNION |@� JST_VALIDATE �@ � JST_WITHIN �@ � JST_X V@ � JST_Y W@� JSUBDATE �@ � JSUBSTR �@ � JSUBSTRING �@ � JSUBSTRING_INDEX �@� JSUBTIME �@ � JSUM �@ � JSYSDATE �@ JSYSTEM_USER @ JTAN y@ JTEXT +@ JTIME !@ JTIME FUNCTION �@( JTIMEDIFF �@ 0 JTIMESTAMP @ 8 JTIMESTAMP FUNCTION �@ @ JTIMESTAMPADD �@H JTIMESTAMPDIFF �@ P JTIME_FORMAT �@ X JTIME_TO_SEC �@ ` JTINYBLOB (@h JTINYINT @ p JTINYTEXT )@ x JTOUCHES �@ � JTO_BASE64 �@� JTO_DAYS �@ � JTO_SECONDS �@ � JTRIM �@ � JTRUE @� JTRUNCATE z@ � JTRUNCATE TABLE
@ � JUCASE �@ � JUNCOMPRESS @� JUNCOMPRESSED_LENGTH @ � JUNHEX �@ � JUNINSTALL PLUGIN U@ � JUNION @� JUNIX_TIMESTAMP �@ � JUPDATE @ � JUPDATEXML �@ �UPPER �@ JUSER @ JUTC_DATE �@ JUTC_TIME �@ JUTC_TIMESTAMP �@( JUUID �@ 0 JUUID_SHORT �@ 8 JVALIDATE_PASSWORD_STRENGTH
@ @ JVALUES �@H JVARBINARY '@ P JVARCHAR %@ X JVARIANCE �@ ` JVAR_POP �@h JVAR_SAMP �@ p JVERSION @ x JWAIT_FOR_EXECUTED_GTID_SET �@ � JWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS �@� JWEEK �@ � JWEEKDAY �@ � JWEEKOFYEAR �@ � JWEIGHT_STRING �@� JWHILE <@ � JWITHIN �@ � JWKT DEFINITION 5@ � JX X@� JXA #@ � JXOR O@ � JY Y@ � JYEAR �@� JYEAR DATA TYPE "@ � JYEARWEEK �@ � J^ �@ J| �@ �~ �@ �vUSE � p-L,$*�)�(�'�&\%4$ "�!� � l D ���|T,���d< � �
� tL$����\ cJ��c #� ױ,� @ ��
(����Syntax:
CREATE
[DEFINER = user]
PROCEDURE sp_name ([proc_parameter[,...]])
[characteristic ...] routine_body
CREATE
[DEFINER = user]
FUNCTION sp_name ([func_parameter[,...]])
RETURNS type
[characteristic ...] routine_body
proc_parameter:
[ IN | OUT | INOUT ] param_name type
func_parameter:
param_name type
type:
Any valid MySQL data type
characteristic: {
COMMENT 'string'
| LANGUAGE SQL
| [NOT] DETERMINISTIC
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
}
routine_body:
Valid SQL routine statement
These statements are used to create a stored routine (a stored
procedure or function). That is, the specified routine becomes known to
the server. By default, a stored routine is associated with the default
database. To associate the routine explicitly with a given database,
specify the name as db_name.sp_name when you create it.
The CREATE FUNCTION statement is also used in MySQL to support loadable
functions. See [HELP CREATE FUNCTION loadable function]. A loadable
function can be regarded as an external stored function. Stored
functions share their namespace with loadable functions. See
https://dev.mysql.com/doc/refman/5.7/en/function-resolution.html, for
the rules describing how the server interprets references to different
kinds of functions.
To invoke a stored procedure, use the CALL statement (see [HELP CALL]).
To invoke a stored function, refer to it in an expression. The function
returns a value during expression evaluation.
CREATE PROCEDURE and CREATE FUNCTION require the CREATE ROUTINE
privilege. If the DEFINER clause is present, the privileges required
depend on the user value, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-objects-security.html.
If binary logging is enabled, CREATE FUNCTION might require the SUPER
privilege, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-programs-logging.html.
By default, MySQL automatically grants the ALTER ROUTINE and EXECUTE
privileges to the routine creator. This behavior can be changed by
disabling the automatic_sp_privileges system variable. See
https://dev.mysql.com/doc/refman/5.7/en/stored-routines-privileges.html
.
The DEFINER and SQL SECURITY clauses specify the security context to be
used when checking access privileges at routine execution time, as
described later in this section.
If the routine name is the same as the name of a built-in SQL function,
a syntax error occurs unless you use a space between the name and the
following parenthesis when defining the routine or invoking it later.
For this reason, avoid using the names of existing SQL functions for
your own stored routines.
The IGNORE_SPACE SQL mode applies to built-in functions, not to stored
routines. It is always permissible to have spaces after a stored
routine name, regardless of whether IGNORE_SPACE is enabled.
The parameter list enclosed within parentheses must always be present.
If there are no parameters, an empty parameter list of () should be
used. Parameter names are not case-sensitive.
Each parameter is an IN parameter by default. To specify otherwise for
a parameter, use the keyword OUT or INOUT before the parameter name.
*Note*:
Specifying a parameter as IN, OUT, or INOUT is valid only for a
PROCEDURE. For a FUNCTION, parameters are always regarded as IN
parameters.
An IN parameter passes a value into a procedure. The procedure might
modify the value, but the modification is not visible to the caller
when the procedure returns. An OUT parameter passes a value from the
procedure back to the caller. Its initial value is NULL within the
procedure, and its value is visible to the caller when the procedure
returns. An INOUT parameter is initialized by the caller, can be
modified by the procedure, and any change made by the procedure is
visible to the caller when the procedure returns.
For each OUT or INOUT parameter, pass a user-defined variable in the
CALL statement that invokes the procedure so that you can obtain its
value when the procedure returns. If you are calling the procedure from
within another stored procedure or function, you can also pass a
routine parameter or local routine variable as an OUT or INOUT
parameter. If you are calling the procedure from within a trigger, you
can also pass NEW.col_name as an OUT or INOUT parameter.
For information about the effect of unhandled conditions on procedure
parameters, see
https://dev.mysql.com/doc/refman/5.7/en/conditions-and-parameters.html.
Routine parameters cannot be referenced in statements prepared within
the routine; see
https://dev.mysql.com/doc/refman/5.7/en/stored-program-restrictions.html
.
The following example shows a simple stored procedure that, given a
country code, counts the number of cities for that country that appear
in the city table of the world database. The country code is passed
using an IN parameter, and the city count is returned using an OUT
parameter:
mysql> delimiter //
mysql> CREATE PROCEDURE citycount (IN country CHAR(3), OUT cities INT)
BEGIN
SELECT COUNT(*) INTO cities FROM world.city
WHERE CountryCode = country;
END//
Query OK, 0 rows affected (0.01 sec)
mysql> delimiter ;
mysql> CALL citycount('JPN', @cities); -- cities in Japan
Query OK, 1 row affected (0.00 sec)
mysql> SELECT @cities;
+---------+
| @cities |
+---------+
| 248 |
+---------+
1 row in set (0.00 sec)
mysql> CALL citycount('FRA', @cities); -- cities in France
Query OK, 1 row affected (0.00 sec)
mysql> SELECT @cities;
+---------+
| @cities |
+---------+
| 40 |
+---------+
1 row in set (0.00 sec)
The example uses the mysql client delimiter command to change the
statement delimiter from ; to // while the procedure is being defined.
This enables the ; delimiter used in the procedure body to be passed
through to the server rather than being interpreted by mysql itself.
See
https://dev.mysql.com/doc/refman/5.7/en/stored-programs-defining.html.
The RETURNS clause may be specified only for a FUNCTION, for which it
is mandatory. It indicates the return type of the function, and the
function body must contain a RETURN value statement. If the RETURN
statement returns a value of a different type, the value is coerced to
the proper type. For example, if a function specifies an ENUM or SET
value in the RETURNS clause, but the RETURN statement returns an
integer, the value returned from the function is the string for the
corresponding ENUM member of set of SET members.
The following example function takes a parameter, performs an operation
using an SQL function, and returns the result. In this case, it is
unnecessary to use delimiter because the function definition contains
no internal ; statement delimiters:
mysql> CREATE FUNCTION hello (s CHAR(20))
mysql> RETURNS CHAR(50) DETERMINISTIC
RETURN CONCAT('Hello, ',s,'!');
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT hello('world');
+----------------+
| hello('world') |
+----------------+
| Hello, world! |
+----------------+
1 row in set (0.00 sec)
Parameter types and function return types can be declared to use any
valid data type. The COLLATE attribute can be used if preceded by a
CHARACTER SET specification.
The routine_body consists of a valid SQL routine statement. This can be
a simple statement such as SELECT or INSERT, or a compound statement
written using BEGIN and END. Compound statements can contain
declarations, loops, and other control structure statements. The syntax
for these statements is described in
https://dev.mysql.com/doc/refman/5.7/en/sql-compound-statements.html.
In practice, stored functions tend to use compound statements, unless
the body consists of a single RETURN statement.
MySQL permits routines to contain DDL statements, such as CREATE and
DROP. MySQL also permits stored procedures (but not stored functions)
to contain SQL transaction statements such as COMMIT. Stored functions
may not contain statements that perform explicit or implicit commit or
rollback. Support for these statements is not required by the SQL
standard, which states that each DBMS vendor may decide whether to
permit them.
Statements that return a result set can be used within a stored
procedure but not within a stored function. This prohibition includes
SELECT statements that do not have an INTO var_list clause and other
statements such as SHOW, EXPLAIN, and CHECK TABLE. For statements that
can be determined at function definition time to return a result set, a
Not allowed to return a result set from a function error occurs
(ER_SP_NO_RETSET
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_sp_no_retset)). For statements that can be determined only
at runtime to return a result set, a PROCEDURE %s can't return a result
set in the given context error occurs (ER_SP_BADSELECT
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_sp_badselect)).
USE statements within stored routines are not permitted. When a routine
is invoked, an implicit USE db_name is performed (and undone when the
routine terminates). The causes the routine to have the given default
database while it executes. References to objects in databases other
than the routine default database should be qualified with the
appropriate database name.
For additional information about statements that are not permitted in
stored routines, see
https://dev.mysql.com/doc/refman/5.7/en/stored-program-restrictions.html
.
For information about invoking stored procedures from within programs
written in a language that has a MySQL interface, see [HELP CALL].
MySQL stores the sql_mode system variable setting in effect when a
routine is created or altered, and always executes the routine with
this setting in force, regardless of the current server SQL mode when
the routine begins executing.
The switch from the SQL mode of the invoker to that of the routine
occurs after evaluation of arguments and assignment of the resulting
values to routine parameters. If you define a routine in strict SQL
mode but invoke it in nonstrict mode, assignment of arguments to
routine parameters does not take place in strict mode. If you require
that expressions passed to a routine be assigned in strict SQL mode,
you should invoke the routine with strict mode in effect.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-procedure.html
ױ,� ��|�Ȑ A �E
(����Syntax:
CREATE
[DEFINER = user]
PROCEDURE sp_name ([proc_parameter[,...]])
[characteristic ...] routine_body
CREATE
[DEFINER = user]
FUNCTION sp_name ([func_parameter[,...]])
RETURNS type
[characteristic ...] routine_body
proc_parameter:
[ IN | OUT | INOUT ] param_name type
func_parameter:
param_name type
type:
Any valid MySQL data type
characteristic: {
COMMENT 'string'
| LANGUAGE SQL
| [NOT] DETERMINISTIC
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
}
routine_body:
Valid SQL routine statement
These statements are used to create a stored routine (a stored
procedure or function). That is, the specified routine becomes known to
the server. By default, a stored routine is associated with the default
database. To associate the routine explicitly with a given database,
specify the name as db_name.sp_name when you create it.
The CREATE FUNCTION statement is also used in MySQL to support loadable
functions. See [HELP CREATE FUNCTION loadable function]. A loadable
function can be regarded as an external stored function. Stored
functions share their namespace with loadable functions. See
https://dev.mysql.com/doc/refman/5.7/en/function-resolution.html, for
the rules describing how the server interprets references to different
kinds of functions.
To invoke a stored procedure, use the CALL statement (see [HELP CALL]).
To invoke a stored function, refer to it in an expression. The function
returns a value during expression evaluation.
CREATE PROCEDURE and CREATE FUNCTION require the CREATE ROUTINE
privilege. If the DEFINER clause is present, the privileges required
depend on the user value, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-objects-security.html.
If binary logging is enabled, CREATE FUNCTION might require the SUPER
privilege, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-programs-logging.html.
By default, MySQL automatically grants the ALTER ROUTINE and EXECUTE
privileges to the routine creator. This behavior can be changed by
disabling the automatic_sp_privileges system variable. See
https://dev.mysql.com/doc/refman/5.7/en/stored-routines-privileges.html
.
The DEFINER and SQL SECURITY clauses specify the security context to be
used when checking access privileges at routine execution time, as
described later in this section.
If the routine name is the same as the name of a built-in SQL function,
a syntax error occurs unless you use a space between the name and the
following parenthesis when defining the routine or invoking it later.
For this reason, avoid using the names of existing SQL functions for
your own stored routines.
The IGNORE_SPACE SQL mode applies to built-in functions, not to stored
routines. It is always permissible to have spaces after a stored
routine name, regardless of whether IGNORE_SPACE is enabled.
The parameter list enclosed within parentheses must always be present.
If there are no parameters, an empty parameter list of () should be
used. Parameter names are not case-sensitive.
Each parameter is an IN parameter by default. To specify otherwise for
a parameter, use the keyword OUT or INOUT before the parameter name.
*Note*:
Specifying a parameter as IN, OUT, or INOUT is valid only for a
PROCEDURE. For a FUNCTION, parameters are always regarded as IN
parameters.
An IN parameter passes a value into a procedure. The procedure might
modify the value, but the modification is not visible to the caller
when the procedure returns. An OUT parameter passes a value from the
procedure back to the caller. Its initial value is NULL within the
procedure, and its value is visible to the caller when the procedure
returns. An INOUT parameter is initialized by the caller, can be
modified by the procedure, and any change made by the procedure is
visible to the caller when the procedure returns.
For each OUT or INOUT parameter, pass a user-defined variable in the
CALL statement that invokes the procedure so that you can obtain its
value when the procedure returns. If you are calling the procedure from
within another stored procedure or function, you can also pass a
routine parameter or local routine variable as an OUT or INOUT
parameter. If you are calling the procedure from within a trigger, you
can also pass NEW.col_name as an OUT or INOUT parameter.
For information about the effect of unhandled conditions on procedure
parameters, see
https://dev.mysql.com/doc/refman/5.7/en/conditions-and-parameters.html.
Routine parameters cannot be referenced in statements prepared within
the routine; see
https://dev.mysql.com/doc/refman/5.7/en/stored-program-restrictions.html
.
The following example shows a simple stored procedure that, given a
country code, counts the number of cities for that country that appear
in the city table of the world database. The country code is passed
using an IN parameter, and the city count is returned using an OUT
parameter:
mysql> delimiter //
mysql> CREATE PROCEDURE citycount (IN country CHAR(3), OUT cities INT)
BEGIN
SELECT COUNT(*) INTO cities FROM world.city
WHERE CountryCode = country;
END//
Query OK, 0 rows affected (0.01 sec)
mysql> delimiter ;
mysql> CALL citycount('JPN', @cities); -- cities in Japan
Query OK, 1 row affected (0.00 sec)
mysql> SELECT @cities;
+---------+
| @cities |
+---------+
| 248 |
+---------+
1 row in set (0.00 sec)
mysql> CALL citycount('FRA', @cities); -- cities in France
Query OK, 1 row affected (0.00 sec)
mysql> SELECT @cities;
+---------+
| @cities |
+---------+
| 40 |
+---------+
1 row in set (0.00 sec)
The example uses the mysql client delimiter command to change the
statement delimiter from ; to // while the procedure is being defined.
This enables the ; delimiter used in the procedure body to be passed
through to the server rather than being interpreted by mysql itself.
See
https://dev.mysql.com/doc/refman/5.7/en/stored-programs-defining.html.
The RETURNS clause may be specified only for a FUNCTION, for which it
is mandatory. It indicates the return type of the function, and the
function body must contain a RETURN value statement. If the RETURN
statement returns a value of a different type, the value is coerced to
the proper type. For example, if a function specifies an ENUM or SET
value in the RETURNS clause, but the RETURN statement returns an
integer, the value returned from the function is the string for the
corresponding ENUM member of set of SET members.
The following example function takes a parameter, performs an operation
using an SQL function, and returns the result. In this case, it is
unnecessary to use delimiter because the function definition contains
no internal ; statement delimiters:
mysql> CREATE FUNCTION hello (s CHAR(20))
mysql> RETURNS CHAR(50) DETERMINISTIC
RETURN CONCAT('Hello, ',s,'!');
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT hello('world');
+----------------+
| hello('world') |
+----------------+
| Hello, world! |
+----------------+
1 row in set (0.00 sec)
Parameter types and function return types can be declared to use any
valid data type. The COLLATE attribute can be used if preceded by a
CHARACTER SET specification.
The routine_body consists of a valid SQL routine statement. This can be
a simple statement such as SELECT or INSERT, or a compound statement
written using BEGIN and END. Compound statements can contain
declarations, loops, and other control structure statements. The syntax
for these statements is described in
https://dev.mysql.com/doc/refman/5.7/en/sql-compound-statements.html.
In practice, stored functions tend to use compound statements, unless
the body consists of a single RETURN statement.
MySQL permits routines to contain DDL statements, such as CREATE and
DROP. MySQL also permits stored procedures (but not stored functions)
to contain SQL transaction statements such as COMMIT. Stored functions
may not contain statements that perform explicit or implicit commit or
rollback. Support for these statements is not required by the SQL
standard, which states that each DBMS vendor may decide whether to
permit them.
Statements that return a result set can be used within a stored
procedure but not within a stored function. This prohibition includes
SELECT statements that do not have an INTO var_list clause and other
statements such as SHOW, EXPLAIN, and CHECK TABLE. For statements that
can be determined at function definition time to return a result set, a
Not allowed to return a result set from a function error occurs
(ER_SP_NO_RETSET
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_sp_no_retset)). For statements that can be determined only
at runtime to return a result set, a PROCEDURE %s can't return a result
set in the given context error occurs (ER_SP_BADSELECT
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_sp_badselect)).
USE statements within stored routines are not permitted. When a routine
is invoked, an implicit USE db_name is performed (and undone when the
routine terminates). The causes the routine to have the given default
database while it executes. References to objects in databases other
than the routine default database should be qualified with the
appropriate database name.
For additional information about statements that are not permitted in
stored routines, see
https://dev.mysql.com/doc/refman/5.7/en/stored-program-restrictions.html
.
For information about invoking stored procedures from within programs
written in a language that has a MySQL interface, see [HELP CALL].
MySQL stores the sql_mode system variable setting in effect when a
routine is created or altered, and always executes the routine with
this setting in force, regardless of the current server SQL mode when
the routine begins executing.
The switch from the SQL mode of the invoker to that of the routine
occurs after evaluation of arguments and assignment of the resulting
values to routine parameters. If you define a routine in strict SQL
mode but invoke it in nonstrict mode, assignment of arguments to
routine parameters does not take place in strict mode. If you require
that expressions passed to a routine be assigned in strict SQL mode,
you should invoke the routine with strict mode in effect.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-procedure.html
|�Ȑ �E �~~ B ' F �<E� 7ŀ 3�
infimum supremum9 @�@ � � "� 6 [CREATE TABLE &Syntax:
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
(create_definition,...)
[table_options]
[partition_options]
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(create_definition,...)]
[table_options]
[partition_options]
[IGNORE | REPLACE]
[AS] query_expression
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
{ LIKE old_tbl_name | (LIKE old_tbl_name) }
create_definition: {
col_name column_definition
| {INDEX | KEY} [index_name] [index_type] (key_part,...)
[index_option] ...
| {FULLTEXT | SPATIAL} [INDEX | KEY] [index_name] (key_part,...)
[index_option] ...
| [CONSTRAINT [symbol]] PRIMARY KEY
[index_type] (key_part,...)
[index_option] ...
| [CONSTRAINT [symbol]] UNIQUE [INDEX | KEY]
[index_name] [index_type] (key_part,...)
[index_option] ...
| [CONSTRAINT [symbol]] FOREIGN KEY
[index_name] (col_name,...)
reference_definition
| CHECK (expr)
}
column_definition: {
data_type [NOT NULL | NULL] [DEFAULT default_value]
[AUTO_INCREMENT] [UNIQUE [KEY]] [[PRIMARY] KEY]
[COMMENT 'string']
[COLLATE collation_name]
[COLUMN_FORMAT {FIXED | DYNAMIC | DEFAULT}]
[STORAGE {DISK | MEMORY}]
[reference_definition]
| data_type
[COLLATE collation_name]
[GENERATED ALWAYS] AS (expr)
[VIRTUAL | STORED] [NOT NULL | NULL]
[UNIQUE [KEY]] [[PRIMARY] KEY]
[COMMENT 'string']
[reference_definition]
}
data_type:
(see https://dev.mysql.com/doc/refman/5.7/en/data-types.html)
key_part:
col_name [(length)] [ASC | DESC]
index_type:
USING {BTREE | HASH}
index_option: {
KEY_BLOCK_SIZE [=] value
| index_type
| WITH PARSER parser_name
| COMMENT 'string'
}
reference_definition:
REFERENCES tbl_name (key_part,...)
[MATCH FULL | MATCH PARTIAL | MATCH SIMPLE]
[ON DELETE reference_option]
[ON UPDATE reference_option]
reference_option:
RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT
table_options:
table_option [[,] table_option] ...
table_option: {
AUTO_INCREMENT [=] value
| AVG_ROW_LENGTH [=] value
| [DEFAULT] CHARACTER SET [=] charset_name
| CHECKSUM [=] {0 | 1}
| [DEFAULT] COLLATE [=] collation_name
| COMMENT [=] 'string'
| COMPRESSION [=] {'ZLIB' | 'LZ4' | 'NONE'}
| CONNECTION [=] 'connect_string'
| {DATA | INDEX} DIRECTORY [=] 'absolute path to directory'
| DELAY_KEY_WRITE [=] {0 | 1}
| ENCRYPTION [=] {'Y' | 'N'}
| ENGINE [=] engine_name
| INSERT_METHOD [=] { NO | FIRST | LAST }
| KEY_BLOCK_SIZE [=] value
| MAX_ROWS [=] value
| MIN_ROWS [=] value
| PACK_KEYS [=] {0 | 1 | DEFAULT}
| PASSWORD [=] 'string'
| ROW_FORMAT [=] {DEFAULT | DYNAMIC | FIXED | COMPRESSED | REDUNDANT | COMPACT}
| STATS_AUTO_RECALC [=] {DEFAULT | 0 | 1}
| STATS_PERSISTENT [=] {DEFAULT | 0 | 1}
| STATS_SAMPLE_PAGES [=] value
| tablespace_option
| UNION [=] (tbl_name[,tbl_name]...)
}
partition_options:
PARTITION BY
{ [LINEAR] HASH(expr)
| [LINEAR] KEY [ALGORITHM={1 | 2}] (column_list)
| RANGE{(expr) | COLUMNS(column_list)}
| LIST{(expr) | COLUMNS(column_list)} }
[PARTITIONS num]
[SUBPARTITION BY
{ [LINEAR] HASH(expr)
| [LINEAR] KEY [ALGORITHM={1 | 2}] (column_list) }
[SUBPARTITIONS num]
]
[(partition_definition [, partition_definition] ...)]
partition_definition:
PARTITION partition_name
[VALUES
{LESS THAN {(expr | value_list) | MAXVALUE}
|
IN (value_list)}]
[[STORAGE] ENGINE [=] engine_name]
[COMMENT [=] 'string' ]
[DATA DIRECTORY [=] 'data_dir']
[INDEX DIRECTORY [=] 'index_dir']
[MAX_ROWS [=] max_number_of_rows]
[MIN_ROWS [=] min_number_of_rows]
[TABLESPACE [=] tablespace_name]
[(subpartition_definition [, subpartition_definition] ...)]
subpartition_definition:
SUBPARTITION logical_name
[[STORAGE] ENGINE [=] engine_name]
[COMMENT [=] 'string' ]
[DATA DIRECTORY [=] 'data_dir']
[INDEX DIRECTORY [=] 'index_dir']
[MAX_ROWS [=] max_number_of_rows]
[MIN_ROWS [=] min_number_of_rows]
[TABLESPACE [=] tablespace_name]
tablespace_option:
TABLESPACE tablespace_name [STORAGE DISK]
| [TABLESPACE tablespace_name] STORAGE MEMORY
query_expression:
SELECT ... (Some valid select or union statement)
CREATE TABLE creates a table with the given name. You must have the
CREATE privilege for the table.
By default, tables are created in the default database, using the
InnoDB storage engine. An error occurs if the table exists, if there is
no default database, or if the database does not exist.
MySQL has no limit on the number of tables. The underlying file system
may have a limit on the number of files that represent tables.
Individual storage engines may impose engine-specific constraints.
InnoDB permits up to 4 billion tables.
For information about the physical representation of a table, see
https://dev.mysql.com/doc/refman/5.7/en/create-table-files.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-table.html
https://dev.mysql.com/doc/refman/5.7/en/create-table.htmlF��M�@ � � "� 6 hFOREIGN KEY &MySQL supports foreign keys, which permit cross-referencing related
data across tables, and foreign key constraints, which help keep the
related data consistent.
A foreign key relationship involves a parent table that holds the
initial column values, and a child table with column values that
reference the parent column values. A foreign key constraint is defined
on the child table.
The essential syntax for a defining a foreign key constraint in a
CREATE TABLE or ALTER TABLE statement includes the following:
[CONSTRAINT [symbol]] FOREIGN KEY
[index_name] (col_name, ...)
REFERENCES tbl_name (col_name,...)
[ON DELETE reference_option]
[ON UPDATE reference_option]
reference_option:
RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT
URL: https://dev.mysql.com/doc/refman/5.7/en/create-table-foreign-keys.html
CREATE TABLE product (
category INT NOT NULL, id INT NOT NULL,
price DECIMAL,
PRIMARY KEY(category, id)
) ENGINE=INNODB;
CREATE TABLE customer (
id INT NOT NULL,
PRIMARY KEY (id)
) ENGINE=INNODB;
CREATE TABLE product_order (
no INT NOT NULL AUTO_INCREMENT,
product_category INT NOT NULL,
product_id INT NOT NULL,
customer_id INT NOT NULL,
PRIMARY KEY(no),
INDEX (product_category, product_id),
INDEX (customer_id),
FOREIGN KEY (product_category, product_id)
REFERENCES product(category, id)
ON UPDATE CASCADE ON DELETE RESTRICT,
FOREIGN KEY (customer_id)
REFERENCES customer(id)
) ENGINE=INNODB;
https://dev.mysql.com/doc/refman/5.7/en/create-table-foreign-keys.html> �@ � � "� 6 uCREATE TABLESPACE & C & L�https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html; �@ (
� � "� 6 �CREATE TRIGGER &Syntax:
CREATE
[DEFINER = user]
TRIGGER trigger_name
trigger_time trigger_event
ON tbl_name FOR EACH ROW
[trigger_order]
trigger_body
trigger_time: { BEFORE | AFTER }
trigger_event: { INSERT | UPDATE | DELETE }
trigger_order: { FOLLOWS | PRECEDES } other_trigger_name
This statement creates a new trigger. A trigger is a named database
object that is associated with a table, and that activates when a
particular event occurs for the table. The trigger becomes associated
with the table named tbl_name, which must refer to a permanent table.
You cannot associate a trigger with a TEMPORARY table or a view.
Trigger names exist in the schema namespace, meaning that all triggers
must have unique names within a schema. Triggers in different schemas
can have the same name.
This section describes CREATE TRIGGER syntax. For additional
discussion, see
https://dev.mysql.com/doc/refman/5.7/en/trigger-syntax.html.
CREATE TRIGGER requires the TRIGGER privilege for the table associated
with the trigger. If the DEFINER clause is present, the privileges
required depend on the user value, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-objects-security.html.
If binary logging is enabled, CREATE TRIGGER might require the SUPER
privilege, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-programs-logging.html.
The DEFINER clause determines the security context to be used when
checking access privileges at trigger activation time, as described
later in this section.
trigger_time is the trigger action time. It can be BEFORE or AFTER to
indicate that the trigger activates before or after each row to be
modified.
Basic column value checks occur prior to trigger activation, so you
cannot use BEFORE triggers to convert values inappropriate for the
column type to valid values.
trigger_event indicates the kind of operation that activates the
trigger. These trigger_event values are permitted:
o INSERT: The trigger activates whenever a new row is inserted into the
table (for example, through INSERT, LOAD DATA, and REPLACE
statements).
o UPDATE: The trigger activates whenever a row is modified (for
example, through UPDATE statements).
o DELETE: The trigger activates whenever a row is deleted from the
table (for example, through DELETE and REPLACE statements). DROP
TABLE and TRUNCATE TABLE statements on the table do not activate this
trigger, because they do not use DELETE. Dropping a partition does
not activate DELETE triggers, either.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-trigger.html
https://dev.mysql.com/doc/refman/5.7/en/create-trigger.html8 �@ 0 � � "� 6 �CREATE VIEW & E & 0�https://dev.mysql.com/doc/refman/5.7/en/create-view.html: W�@ 8� � "� 6 �DROP DATABASE &Syntax:
DROP {DATABASE | SCHEMA} [IF EXISTS] db_name
DROP DATABASE drops all tables in the database and deletes the
database. Be very careful with this statement! To use DROP DATABASE,
you need the DROP privilege on the database. DROP SCHEMA is a synonym
for DROP DATABASE.
*Important*:
When a database is dropped, privileges granted specifically for the
database are not automatically dropped. They must be dropped manually.
See [HELP GRANT].
IF EXISTS is used to prevent an error from occurring if the database
does not exist.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-database.html
https://dev.mysql.com/doc/refman/5.7/en/drop-database.html: W�@ @� � "� 6 �DROP SCHEMA &Syntax:
DROP {DATABASE | SCHEMA} [IF EXISTS] db_name
DROP DATABASE drops all tables in the database and deletes the
database. Be very careful with this statement! To use DROP DATABASE,
you need the DROP privilege on the database. DROP SCHEMA is a synonym
for DROP DATABASE.
*Important*:
When a database is dropped, privileges granted specifically for the
database are not automatically dropped. They must be dropped manually.
See [HELP GRANT].
IF EXISTS is used to prevent an error from occurring if the database
does not exist.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-database.html
https://dev.mysql.com/doc/refman/5.7/en/drop-database.html7 +�@ H� "� 6 �DROP EVENT &Syntax:
DROP EVENT [IF EXISTS] event_name
This statement drops the event named event_name. The event immediately
ceases being active, and is deleted completely from the server.
If the event does not exist, the error ERROR 1517 (HY000): Unknown
event 'event_name' results. You can override this and cause the
statement to generate a warning for nonexistent events instead using IF
EXISTS.
This statement requires the EVENT privilege for the schema to which the
event to be dropped belongs.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-event.html
https://dev.mysql.com/doc/refman/5.7/en/drop-event.html7 b�@ P� "� 6 �DROP INDEX &Syntax:
DROP INDEX index_name ON tbl_name
[algorithm_option | lock_option] ...
algorithm_option:
ALGORITHM [=] {DEFAULT | INPLACE | COPY}
lock_option:
LOCK [=] {DEFAULT | NONE | SHARED | EXCLUSIVE}
DROP INDEX drops the index named index_name from the table tbl_name.
This statement is mapped to an ALTER TABLE statement to drop the index.
See [HELP ALTER TABLE].
To drop a primary key, the index name is always PRIMARY, which must be
specified as a quoted identifier because PRIMARY is a reserved word:
DROP INDEX `PRIMARY` ON t;
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-index.html
https://dev.mysql.com/doc/refman/5.7/en/drop-index.html; ��@ X�� "� 6 �DROP PROCEDURE &Syntax:
DROP {PROCEDURE | FUNCTION} [IF EXISTS] sp_name
These statements are used to drop a stored routine (a stored procedure
or function). That is, the specified routine is removed from the
server. (DROP FUNCTION is also used to drop loadable functions; see
[HELP DROP FUNCTION loadable function].)
To drop a stored routine, you must have the ALTER ROUTINE privilege for
it. (If the automatic_sp_privileges system variable is enabled, that
privilege and EXECUTE are granted automatically to the routine creator
when the routine is created and dropped from the creator when the
routine is dropped. See
https://dev.mysql.com/doc/refman/5.7/en/stored-routines-privileges.html
.)
The IF EXISTS clause is a MySQL extension. It prevents an error from
occurring if the procedure or function does not exist. A warning is
produced that can be viewed with SHOW WARNINGS.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-procedure.html
https://dev.mysql.com/doc/refman/5.7/en/drop-procedure.html p � c �~~ �<�V�� C &5
?� DSyntax:
CREATE TABLESPACE tablespace_name
InnoDB and NDB:
ADD DATAFILE 'file_name'
InnoDB only:
[FILE_BLOCK_SIZE = value]
NDB only:
USE LOGFILE GROUP logfile_group
[EXTENT_SIZE [=] extent_size]
[INITIAL_SIZE [=] initial_size]
[AUTOEXTEND_SIZE [=] autoextend_size]
[MAX_SIZE [=] max_size]
[NODEGROUP [=] nodegroup_id]
[WAIT]
[COMMENT [=] 'string']
InnoDB and NDB:
[ENGINE [=] engine_name]
This statement is used to create a tablespace. The precise syntax and
semantics depend on the storage engine used. In standard MySQL 5.7
releases, this is always an InnoDB tablespace. MySQL NDB Cluster 7.5
also supports tablespaces using the NDB storage engine in addition to
those using InnoDB.
o https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html#create
-tablespace-innodb
o https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html#create
-tablespace-ndb
o https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html#create
-tablespace-options
o https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html#create
-tablespace-notes
o https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html#create
-tablespace-innodb-examples
o https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html#create
-tablespace-ndb-examples
Considerations for InnoDB
CREATE TABLESPACE syntax is used to create general tablespaces. A
general tablespace is a shared tablespace. It can hold multiple tables,
and supports all table row formats. General tablespaces can be created
in a location relative to or independent of the data directory.
After creating an InnoDB general tablespace, you can use CREATE TABLE
tbl_name ... TABLESPACE [=] tablespace_name or ALTER TABLE tbl_name
TABLESPACE [=] tablespace_name to add tables to the tablespace. For
more information, see
https://dev.mysql.com/doc/refman/5.7/en/general-tablespaces.html.
Considerations for NDB Cluster
This statement is used to create a tablespace, which can contain one or
more data files, providing storage space for NDB Cluster Disk Data
tables (see
https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data.html).
One data file is created and added to the tablespace using this
statement. Additional data files may be added to the tablespace by
using the ALTER TABLESPACE statement (see [HELP ALTER TABLESPACE]).
*Note*:
All NDB Cluster Disk Data objects share the same namespace. This means
that each Disk Data object must be uniquely named (and not merely each
Disk Data object of a given type). For example, you cannot have a
tablespace and a log file group with the same name, or a tablespace and
a data file with the same name.
A log file group of one or more UNDO log files must be assigned to the
tablespace to be created with the USE LOGFILE GROUP clause.
logfile_group must be an existing log file group created with CREATE
LOGFILE GROUP (see [HELP CREATE LOGFILE GROUP]). Multiple tablespaces
may use the same log file group for UNDO logging.
When setting EXTENT_SIZE or INITIAL_SIZE, you may optionally follow the
number with a one-letter abbreviation for an order of magnitude,
similar to those used in my.cnf. Generally, this is one of the letters
M (for megabytes) or G (for gigabytes).
INITIAL_SIZE and EXTENT_SIZE are subject to rounding as follows:
o EXTENT_SIZE is rounded up to the nearest whole multiple of 32K.
o INITIAL_SIZE is rounded down to the nearest whole multiple of 32K;
this result is rounded up to the nearest whole multiple of
EXTENT_SIZE (after any rounding).
*Note*:
NDB reserves 4% of a tablespace for data node restart operations. This
reserved space cannot be used for data storage. This restriction
applies beginning with NDB 7.6.
The rounding just described is done explicitly, and a warning is issued
by the MySQL Server when any such rounding is performed. The rounded
values are also used by the NDB kernel for calculating Information
Schema FILES column values and other purposes. However, to avoid an
unexpected result, we suggest that you always use whole multiples of
32K in specifying these options.
When CREATE TABLESPACE is used with ENGINE [=] NDB, a tablespace and
associated data file are created on each Cluster data node. You can
verify that the data files were created and obtain information about
them by querying the Information Schema FILES table. (See the example
later in this section.)
(See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-files-table.
html.)
Options
o ADD DATAFILE: Defines the name of a tablespace data file; this option
is always required. The file_name, including any specified path, must
be quoted with single or double quotation marks. File names (not
counting the file extension) and directory names must be at least one
byte in length. Zero length file names and directory names are not
supported.
Because there are considerable differences in how InnoDB and NDB
treat data files, the two storage engines are covered separately in
the discussion that follows.
InnoDB data files An InnoDB tablespace supports only a single data
file, whose name must include a .ibd extension.
For an InnoDB tablespace, the data file is created by default in the
MySQL data directory (datadir). To place the data file in a location
other than the default, include an absolute directory path or a path
relative to the default location.
When an InnoDB tablespace is created outside of the data directory,
an isl file is created in the data directory. To avoid conflicts with
implicitly created file-per-table tablespaces, creating an InnoDB
general tablespace in a subdirectory under the data directory is not
supported. When creating an InnoDB general tablespace outside of the
data directory, the directory must exist prior to creating the
tablespace.
*Note*:
In MySQL 5.7, ALTER TABLESPACE is not supported by InnoDB.
NDB data files An NDB tablespace supports multiple data files which
can have any legal file names; more data files can be added to an NDB
Cluster tablespace following its creation by using an ALTER
TABLESPACE statement.
An NDB tablespace data file is created by default in the data node
file system directory---that is, the directory named ndb_nodeid_fs/TS
under the data node's data directory (DataDir), where nodeid is the
data node's NodeId. To place the data file in a location other than
the default, include an absolute directory path or a path relative to
the default location. If the directory specified does not exist, NDB
attempts to create it; the system user account under which the data
node process is running must have the appropriate permissions to do
so.
*Note*:
When determining the path used for a data file, NDB does not expand
the ~ (tilde) character.
When multiple data nodes are run on the same physical host, the
following considerations apply:
o You cannot specify an absolute path when creating a data file.
o It is not possible to create tablespace data files outside the data
node file system directory, unless each data node has a separate
data directory.
o If each data node has its own data directory, data files can be
created anywhere within this directory.
o If each data node has its own data directory, it may also be
possible to create a data file outside the node's data directory
using a relative path, as long as this path resolves to a unique
location on the host file system for each data node running on that
host.
o FILE_BLOCK_SIZE: This option---which is specific to InnoDB, and is
ignored by NDB---defines the block size for the tablespace data file.
Values can be specified in bytes or kilobytes. For example, an 8
kilobyte file block size can be specified as 8192 or 8K. If you do
not specify this option, FILE_BLOCK_SIZE defaults to the
innodb_page_size value. FILE_BLOCK_SIZE is required when you intend
to use the tablespace for storing compressed InnoDB tables
(ROW_FORMAT=COMPRESSED). In this case, you must define the tablespace
FILE_BLOCK_SIZE when creating the tablespace.
If FILE_BLOCK_SIZE is equal the innodb_page_size value, the
tablespace can contain only tables having an uncompressed row format
(COMPACT, REDUNDANT, and DYNAMIC). Tables with a COMPRESSED row
format have a different physical page size than uncompressed tables.
Therefore, compressed tables cannot coexist in the same tablespace as
uncompressed tables.
For a general tablespace to contain compressed tables,
FILE_BLOCK_SIZE must be specified, and the FILE_BLOCK_SIZE value must
be a valid compressed page size in relation to the innodb_page_size
value. Also, the physical page size of the compressed table
(KEY_BLOCK_SIZE) must be equal to FILE_BLOCK_SIZE/1024. For example,
if innodb_page_size=16K, and FILE_BLOCK_SIZE=8K, the KEY_BLOCK_SIZE
of the table must be 8. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/general-tablespaces.html.
o USE LOGFILE GROUP: Required for NDB, this is the name of a log file
group previously created using CREATE LOGFILE GROUP. Not supported
for InnoDB, where it fails with an error.
o EXTENT_SIZE: This option is specific to NDB, and is not supported by
InnoDB, where it fails with an error. EXTENT_SIZE sets the size, in
bytes, of the extents used by any files belonging to the tablespace.
The default value is 1M. The minimum size is 32K, and theoretical
maximum is 2G, although the practical maximum size depends on a
number of factors. In most cases, changing the extent size does not
have any measurable effect on performance, and the default value is
recommended for all but the most unusual situations.
An extent is a unit of disk space allocation. One extent is filled
with as much data as that extent can contain before another extent is
used. In theory, up to 65,535 (64K) extents may used per data file;
however, the recommended maximum is 32,768 (32K). The recommended
maximum size for a single data file is 32G---that is, 32K extents x 1
MB per extent. In addition, once an extent is allocated to a given
partition, it cannot be used to store data from a different
partition; an extent cannot store data from more than one partition.
This means, for example that a tablespace having a single datafile
whose INITIAL_SIZE (described in the following item) is 256 MB and
whose EXTENT_SIZE is 128M has just two extents, and so can be used to
store data from at most two different disk data table partitions.
You can see how many extents remain free in a given data file by
querying the Information Schema FILES table, and so derive an
estimate for how much space remains free in the file. For further
discussion and examples, see
https://dev.mysql.com/doc/refman/5.7/en/information-schema-files-tabl
e.html.
o INITIAL_SIZE: This option is specific to NDB, and is not supported by
InnoDB, where it fails with an error.
The INITIAL_SIZE parameter sets the total size in bytes of the data
file that was specific using ADD DATATFILE. Once this file has been
created, its size cannot be changed; however, you can add more data
files to the tablespace using ALTER TABLESPACE ... ADD DATAFILE.
INITIAL_SIZE is optional; its default value is 134217728 (128 MB).
On 32-bit systems, the maximum supported value for INITIAL_SIZE is
4294967296 (4 GB).
o AUTOEXTEND_SIZE: Currently ignored by MySQL; reserved for possible
future use. Has no effect in any release of MySQL 5.7 or MySQL NDB
Cluster 7.5, regardless of the storage engine used.
o MAX_SIZE: Currently ignored by MySQL; reserved for possible future
use. Has no effect in any release of MySQL 5.7 or MySQL NDB Cluster
7.5, regardless of the storage engine used.
o NODEGROUP: Currently ignored by MySQL; reserved for possible future
use. Has no effect in any release of MySQL 5.7 or MySQL NDB Cluster
7.5, regardless of the storage engine used.
o WAIT: Currently ignored by MySQL; reserved for possible future use.
Has no effect in any release of MySQL 5.7 or MySQL NDB Cluster 7.5,
regardless of the storage engine used.
o COMMENT: Currently ignored by MySQL; reserved for possible future
use. Has no effect in any release of MySQL 5.7 or MySQL NDB Cluster
7.5, regardless of the storage engine used.
o ENGINE: Defines the storage engine which uses the tablespace, where
engine_name is the name of the storage engine. Currently, only the
InnoDB storage engine is supported by standard MySQL 5.7 releases.
MySQL NDB Cluster 7.5 supports both NDB and InnoDB tablespaces. The
value of the default_storage_engine system variable is used for
ENGINE if the option is not specified.
Notes
o For the rules covering the naming of MySQL tablespaces, see
https://dev.mysql.com/doc/refman/5.7/en/identifiers.html. In addition
to these rules, the slash character ("/") is not permitted, nor can
you use names beginning with innodb_, as this prefix is reserved for
system use.
o Tablespaces do not support temporary tables.
o innodb_file_per_table, innodb_file_format, and innodb_file_format_max
settings have no influence on CREATE TABLESPACE operations.
innodb_file_per_table does not need to be enabled. General
tablespaces support all table row formats regardless of file format
settings. Likewise, general tablespaces support the addition of
tables of any row format using CREATE TABLE ... TABLESPACE,
regardless of file format settings.
o innodb_strict_mode is not applicable to general tablespaces.
Tablespace management rules are strictly enforced independently of
innodb_strict_mode. If CREATE TABLESPACE parameters are incorrect or
incompatible, the operation fails regardless of the
innodb_strict_mode setting. When a table is added to a general
tablespace using CREATE TABLE ... TABLESPACE or ALTER TABLE ...
TABLESPACE, innodb_strict_mode is ignored but the statement is
evaluated as if innodb_strict_mode is enabled.
o Use DROP TABLESPACE to remove a tablespace. All tables must be
dropped from a tablespace using DROP TABLE prior to dropping the
tablespace. Before dropping an NDB Cluster tablespace you must also
remove all its data files using one or more ALTER TABLESPACE ... DROP
DATATFILE statements. See
https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data-objec
ts.html.
o All parts of an InnoDB table added to an InnoDB general tablespace
reside in the general tablespace, including indexes and BLOB pages.
For an NDB table assigned to a tablespace, only those columns which
are not indexed are stored on disk, and actually use the tablespace
data files. Indexes and indexed columns for all NDB tables are always
kept in memory.
o Similar to the system tablespace, truncating or dropping tables
stored in a general tablespace creates free space internally in the
general tablespace .ibd data file which can only be used for new
InnoDB data. Space is not released back to the operating system as it
is for file-per-table tablespaces.
o A general tablespace is not associated with any database or schema.
o ALTER TABLE ... DISCARD TABLESPACE and ALTER TABLE ...IMPORT
TABLESPACE are not supported for tables that belong to a general
tablespace.
o The server uses tablespace-level metadata locking for DDL that
references general tablespaces. By comparison, the server uses
table-level metadata locking for DDL that references file-per-table
tablespaces.
o A generated or existing tablespace cannot be changed to a general
tablespace.
o Tables stored in a general tablespace can only be opened in MySQL
5.7.6 or later due to the addition of new table flags.
o There is no conflict between general tablespace names and
file-per-table tablespace names. The "/" character, which is present
in file-per-table tablespace names, is not permitted in general
tablespace names.
o mysqldump and mysqlpump do not dump InnoDB CREATE TABLESPACE
statements.
InnoDB Examples
This example demonstrates creating a general tablespace and adding
three uncompressed tables of different row formats.
mysql> CREATE TABLESPACE `ts1` ADD DATAFILE 'ts1.ibd' ENGINE=INNODB;
mysql> CREATE TABLE t1 (c1 INT PRIMARY KEY) TABLESPACE t�V�� &5�Jq D &5
����s1 ROW_FORMAT=REDUNDANT;
mysql> CREATE TABLE t2 (c1 INT PRIMARY KEY) TABLESPACE ts1 ROW_FORMAT=COMPACT;
mysql> CREATE TABLE t3 (c1 INT PRIMARY KEY) TABLESPACE ts1 ROW_FORMAT=DYNAMIC;
This example demonstrates creating a general tablespace and adding a
compressed table. The example assumes a default innodb_page_size value
of 16K. The FILE_BLOCK_SIZE of 8192 requires that the compressed table
have a KEY_BLOCK_SIZE of 8.
mysql> CREATE TABLESPACE `ts2` ADD DATAFILE 'ts2.ibd' FILE_BLOCK_SIZE = 8192 Engine=InnoDB;
mysql> CREATE TABLE t4 (c1 INT PRIMARY KEY) TABLESPACE ts2 ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=8;
NDB Example
Suppose that you wish to create an NDB Cluster Disk Data tablespace
named myts using a datafile named mydata-1.dat. An NDB tablespace
always requires the use of a log file group consisting of one or more
undo log files. For this example, we first create a log file group
named mylg that contains one undo long file named myundo-1.dat, using
the CREATE LOGFILE GROUP statement shown here:
mysql> CREATE LOGFILE GROUP myg1
-> ADD UNDOFILE 'myundo-1.dat'
-> ENGINE=NDB;
Query OK, 0 rows affected (3.29 sec)
Now you can create the tablespace previously described using the
following statement:
mysql> CREATE TABLESPACE myts
-> ADD DATAFILE 'mydata-1.dat'
-> USE LOGFILE GROUP mylg
-> ENGINE=NDB;
Query OK, 0 rows affected (2.98 sec)
You can now create a Disk Data table using a CREATE TABLE statement
with the TABLESPACE and STORAGE DISK options, similar to what is shown
here:
mysql> CREATE TABLE mytable (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> lname VARCHAR(50) NOT NULL,
-> fname VARCHAR(50) NOT NULL,
-> dob DATE NOT NULL,
-> joined DATE NOT NULL,
-> INDEX(last_name, first_name)
-> )
-> TABLESPACE myts STORAGE DISK
-> ENGINE=NDB;
Query OK, 0 rows affected (1.41 sec)
It is important to note that only the dob and joined columns from
mytable are actually stored on disk, due to the fact that the id,
lname, and fname columns are all indexed.
As mentioned previously, when CREATE TABLESPACE is used with ENGINE [=]
NDB, a tablespace and associated data file are created on each NDB
Cluster data node. You can verify that the data files were created and
obtain information about them by querying the Information Schema FILES
table, as shown here:
mysql> SELECT FILE_NAME, FILE_TYPE, LOGFILE_GROUP_NAME, STATUS, EXTRA
-> FROM INFORMATION_SCHEMA.FILES
-> WHERE TABLESPACE_NAME = 'myts';
+--------------+------------+--------------------+--------+----------------+
| file_name | file_type | logfile_group_name | status | extra |
+--------------+------------+--------------------+--------+----------------+
| mydata-1.dat | DATAFILE | mylg | NORMAL | CLUSTER_NODE=5 |
| mydata-1.dat | DATAFILE | mylg | NORMAL | CLUSTER_NODE=6 |
| NULL | TABLESPACE | mylg | NORMAL | NULL |
+--------------+------------+--------------------+--------+----------------+
3 rows in set (0.01 sec)
For additional information and examples, see
https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data-objects
.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html
�Jq &5>�� E e\
0�����Syntax:
CREATE
[OR REPLACE]
[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
[DEFINER = user]
[SQL SECURITY { DEFINER | INVOKER }]
VIEW view_name [(column_list)]
AS select_statement
[WITH [CASCADED | LOCAL] CHECK OPTION]
The CREATE VIEW statement creates a new view, or replaces an existing
view if the OR REPLACE clause is given. If the view does not exist,
CREATE OR REPLACE VIEW is the same as CREATE VIEW. If the view does
exist, CREATE OR REPLACE VIEW replaces it.
For information about restrictions on view use, see
https://dev.mysql.com/doc/refman/5.7/en/view-restrictions.html.
The select_statement is a SELECT statement that provides the definition
of the view. (Selecting from the view selects, in effect, using the
SELECT statement.) The select_statement can select from base tables or
from other views.
The view definition is "frozen" at creation time and is not affected by
subsequent changes to the definitions of the underlying tables. For
example, if a view is defined as SELECT * on a table, new columns added
to the table later do not become part of the view, and columns dropped
from the table result in an error when selecting from the view.
The ALGORITHM clause affects how MySQL processes the view. The DEFINER
and SQL SECURITY clauses specify the security context to be used when
checking access privileges at view invocation time. The WITH CHECK
OPTION clause can be given to constrain inserts or updates to rows in
tables referenced by the view. These clauses are described later in
this section.
The CREATE VIEW statement requires the CREATE VIEW privilege for the
view, and some privilege for each column selected by the SELECT
statement. For columns used elsewhere in the SELECT statement, you must
have the SELECT privilege. If the OR REPLACE clause is present, you
must also have the DROP privilege for the view. If the DEFINER clause
is present, the privileges required depend on the user value, as
discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-objects-security.html.
When a view is referenced, privilege checking occurs as described later
in this section.
A view belongs to a database. By default, a new view is created in the
default database. To create the view explicitly in a given database,
use db_name.view_name syntax to qualify the view name with the database
name:
CREATE VIEW test.v AS SELECT * FROM t;
Unqualified table or view names in the SELECT statement are also
interpreted with respect to the default database. A view can refer to
tables or views in other databases by qualifying the table or view name
with the appropriate database name.
Within a database, base tables and views share the same namespace, so a
base table and a view cannot have the same name.
Columns retrieved by the SELECT statement can be simple references to
table columns, or expressions that use functions, constant values,
operators, and so forth.
A view must have unique column names with no duplicates, just like a
base table. By default, the names of the columns retrieved by the
SELECT statement are used for the view column names. To define explicit
names for the view columns, specify the optional column_list clause as
a list of comma-separated identifiers. The number of names in
column_list must be the same as the number of columns retrieved by the
SELECT statement.
A view can be created from many kinds of SELECT statements. It can
refer to base tables or other views. It can use joins, UNION, and
subqueries. The SELECT need not even refer to any tables:
CREATE VIEW v_today (today) AS SELECT CURRENT_DATE;
The following example defines a view that selects two columns from
another table as well as an expression calculated from those columns:
mysql> CREATE TABLE t (qty INT, price INT);
mysql> INSERT INTO t VALUES(3, 50);
mysql> CREATE VIEW v AS SELECT qty, price, qty*price AS value FROM t;
mysql> SELECT * FROM v;
+------+-------+-------+
| qty | price | value |
+------+-------+-------+
| 3 | 50 | 150 |
+------+-------+-------+
A view definition is subject to the following restrictions:
o The SELECT statement cannot refer to system variables or user-defined
variables.
o Within a stored program, the SELECT statement cannot refer to program
parameters or local variables.
o The SELECT statement cannot refer to prepared statement parameters.
o Any table or view referred to in the definition must exist. If, after
the view has been created, a table or view that the definition refers
to is dropped, use of the view results in an error. To check a view
definition for problems of this kind, use the CHECK TABLE statement.
o The definition cannot refer to a TEMPORARY table, and you cannot
create a TEMPORARY view.
o You cannot associate a trigger with a view.
o Aliases for column names in the SELECT statement are checked against
the maximum column length of 64 characters (not the maximum alias
length of 256 characters).
ORDER BY is permitted in a view definition, but it is ignored if you
select from a view using a statement that has its own ORDER BY.
For other options or clauses in the definition, they are added to the
options or clauses of the statement that references the view, but the
effect is undefined. For example, if a view definition includes a LIMIT
clause, and you select from the view using a statement that has its own
LIMIT clause, it is undefined which limit applies. This same principle
applies to options such as ALL, DISTINCT, or SQL_SMALL_RESULT that
follow the SELECT keyword, and to clauses such as INTO, FOR UPDATE,
LOCK IN SHARE MODE, and PROCEDURE.
The results obtained from a view may be affected if you change the
query processing environment by changing system variables:
mysql> CREATE VIEW v (mycol) AS SELECT 'abc';
Query OK, 0 rows affected (0.01 sec)
mysql> SET sql_mode = '';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT "mycol" FROM v;
+-------+
| mycol |
+-------+
| mycol |
+-------+
1 row in set (0.01 sec)
mysql> SET sql_mode = 'ANSI_QUOTES';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT "mycol" FROM v;
+-------+
| mycol |
+-------+
| abc |
+-------+
1 row in set (0.00 sec)
The DEFINER and SQL SECURITY clauses determine which MySQL account to
use when checking access privileges for the view when a statement is
executed that references the view. The valid SQL SECURITY
characteristic values are DEFINER (the default) and INVOKER. These
indicate that the required privileges must be held by the user who
defined or invoked the view, respectively.
If the DEFINER clause is present, the user value should be a MySQL
account specified as 'user_name'@'host_name', CURRENT_USER, or
CURRENT_USER(). The permitted user values depend on the privileges you
hold, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/stored-objects-security.html.
Also see that section for additional information about view security.
If the DEFINER clause is omitted, the default definer is the user who
executes the CREATE VIEW statement. This is the same as specifying
DEFINER = CURRENT_USER explicitly.
Within a view definition, the CURRENT_USER function returns the view's
DEFINER value by default. For views defined with the SQL SECURITY
INVOKER characteristic, CURRENT_USER returns the account for the view's
invoker. For information about user auditing within views, see
https://dev.mysql.com/doc/refman/5.7/en/account-activity-auditing.html.
Within a stored routine that is defined with the SQL SECURITY DEFINER
characteristic, CURRENT_USER returns the routine's DEFINER value. This
also affects a view defined within such a routine, if the view
definition contains a DEFINER value of CURRENT_USER.
MySQL checks view privileges like this:
o At view definition time, the view creator must have the privileges
needed to use the top-level objects accessed by the view. For
example, if the view definition refers to table columns, the creator
must have some privilege for each column in the select list of the
definition, and the SELECT privilege for each column used elsewhere
in the definition. If the definition refers to a stored function,
only the privileges needed to invoke the function can be checked. The
privileges required at function invocation time can be checked only
as it executes: For different invocations, different execution paths
within the function might be taken.
o The user who references a view must have appropriate privileges to
access it (SELECT to select from it, INSERT to insert into it, and so
forth.)
o When a view has been referenced, privileges for objects accessed by
the view are checked against the privileges held by the view DEFINER
account or invoker, depending on whether the SQL SECURITY
characteristic is DEFINER or INVOKER, respectively.
o If reference to a view causes execution of a stored function,
privilege checking for statements executed within the function depend
on whether the function SQL SECURITY characteristic is DEFINER or
INVOKER. If the security characteristic is DEFINER, the function runs
with the privileges of the DEFINER account. If the characteristic is
INVOKER, the function runs with the privileges determined by the
view's SQL SECURITY characteristic.
Example: A view might depend on a stored function, and that function
might invoke other stored routines. For example, the following view
invokes a stored function f():
CREATE VIEW v AS SELECT * FROM t WHERE t.id = f(t.name);
Suppose that f() contains a statement such as this:
IF name IS NULL then
CALL p1();
ELSE
CALL p2();
END IF;
The privileges required for executing statements within f() need to be
checked when f() executes. This might mean that privileges are needed
for p1() or p2(), depending on the execution path within f(). Those
privileges must be checked at runtime, and the user who must possess
the privileges is determined by the SQL SECURITY values of the view v
and the function f().
The DEFINER and SQL SECURITY clauses for views are extensions to
standard SQL. In standard SQL, views are handled using the rules for
SQL SECURITY DEFINER. The standard says that the definer of the view,
which is the same as the owner of the view's schema, gets applicable
privileges on the view (for example, SELECT) and may grant them. MySQL
has no concept of a schema "owner", so MySQL adds a clause to identify
the definer. The DEFINER clause is an extension where the intent is to
have what the standard has; that is, a permanent record of who defined
the view. This is why the default DEFINER value is the account of the
view creator.
The optional ALGORITHM clause is a MySQL extension to standard SQL. It
affects how MySQL processes the view. ALGORITHM takes three values:
MERGE, TEMPTABLE, or UNDEFINED. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/view-algorithms.html, as well
as
https://dev.mysql.com/doc/refman/5.7/en/derived-table-optimization.html
.
Some views are updatable. That is, you can use them in statements such
as UPDATE, DELETE, or INSERT to update the contents of the underlying
table. For a view to be updatable, there must be a one-to-one
relationship between the rows in the view and the rows in the
underlying table. There are also certain other constructs that make a
view nonupdatable.
A generated column in a view is considered updatable because it is
possible to assign to it. However, if such a column is updated
explicitly, the only permitted value is DEFAULT. For information about
generated columns, see
https://dev.mysql.com/doc/refman/5.7/en/create-table-generated-columns.
html.
The WITH CHECK OPTION clause can be given for an updatable view to
prevent inserts or updates to rows except those for which the WHERE
clause in the select_statement is true.
In a WITH CHECK OPTION clause for an updatable view, the LOCAL and
CASCADED keywords determine the scope of check testing when the view is
defined in terms of another view. The LOCAL keyword restricts the CHECK
OPTION only to the view being defined. CASCADED causes the checks for
underlying views to be evaluated as well. When neither keyword is
given, the default is CASCADED.
For more information about updatable views and the WITH CHECK OPTION
clause, see
https://dev.mysql.com/doc/refman/5.7/en/view-updatability.html, and
https://dev.mysql.com/doc/refman/5.7/en/view-check-option.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-view.html
>�� e\:�Fu F B G �E� 4�� & infimum supremum; ��@ = "� 6 �DROP FUNCTION &Syntax:
DROP {PROCEDURE | FUNCTION} [IF EXISTS] sp_name
These statements are used to drop a stored routine (a stored procedure
or function). That is, the specified routine is removed from the
server. (DROP FUNCTION is also used to drop loadable functions; see
[HELP DROP FUNCTION loadable function].)
To drop a stored routine, you must have the ALTER ROUTINE privilege for
it. (If the automatic_sp_privileges system variable is enabled, that
privilege and EXECUTE are granted automatically to the routine creator
when the routine is created and dropped from the creator when the
routine is dropped. See
https://dev.mysql.com/doc/refman/5.7/en/stored-routines-privileges.html
.)
The IF EXISTS clause is a MySQL extension. It prevents an error from
occurring if the procedure or function does not exist. A warning is
produced that can be viewed with SHOW WARNINGS.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-procedure.html
https://dev.mysql.com/doc/refman/5.7/en/drop-procedure.html8 ��@ H "� 6 �DROP SERVER &Syntax:
DROP SERVER [ IF EXISTS ] server_name
Drops the server definition for the server named server_name. The
corresponding row in the mysql.servers table is deleted. This statement
requires the SUPER privilege.
Dropping a server for a table does not affect any FEDERATED tables that
used this connection information when they were created. See [HELP
CREATE SERVER].
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-server.html
https://dev.mysql.com/doc/refman/5.7/en/drop-server.html7 K�@ � "� 6 �DROP TABLE &Syntax:
DROP [TEMPORARY] TABLE [IF EXISTS]
tbl_name [, tbl_name] ...
[RESTRICT | CASCADE]
DROP TABLE removes one or more tables. You must have the DROP privilege
for each table.
Be careful with this statement! For each table, it removes the table
definition and all table data. If the table is partitioned, the
statement removes the table definition, all its partitions, all data
stored in those partitions, and all partition definitions associated
with the dropped table.
Dropping a table also drops any triggers for the table.
DROP TABLE causes an implicit commit, except when used with the
TEMPORARY keyword. See
https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
*Important*:
When a table is dropped, privileges granted specifically for the table
are not automatically dropped. They must be dropped manually. See [HELP
GRANT].
If any tables named in the argument list do not exist, DROP TABLE
behavior depends on whether the IF EXISTS clause is given:
o Without IF EXISTS, the statement drops all named tables that do
exist, and returns an error indicating which nonexisting tables it
was unable to drop.
o With IF EXISTS, no error occurs for nonexisting tables. The statement
drops all named tables that do exist, and generates a NOTE diagnostic
for each nonexistent table. These notes can be displayed with SHOW
WARNINGS. See [HELP SHOW WARNINGS].
IF EXISTS can also be useful for dropping tables in unusual
circumstances under which there is an .frm file but no table managed by
the storage engine. (For example, if an abnormal server exit occurs
after removal of the table from the storage engine but before .frm file
removal.)
The TEMPORARY keyword has the following effects:
o The statement drops only TEMPORARY tables.
o The statement does not cause an implicit commit.
o No access rights are checked. A TEMPORARY table is visible only with
the session that created it, so no check is necessary.
Including the TEMPORARY keyword is a good way to prevent accidentally
dropping non-TEMPORARY tables.
The RESTRICT and CASCADE keywords do nothing. They are permitted to
make porting easier from other database systems.
DROP TABLE is not supported with all innodb_force_recovery settings.
See
https://dev.mysql.com/doc/refman/5.7/en/forcing-innodb-recovery.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-table.html
https://dev.mysql.com/doc/refman/5.7/en/drop-table.html< u�@ (
"� 6 DROP TABLESPACE &Syntax:
DROP TABLESPACE tablespace_name
[ENGINE [=] engine_name]
This statement drops a tablespace that was previously created using
CREATE TABLESPACE. It is supported with all MySQL NDB Cluster 7.5
releases, and with InnoDB in the standard MySQL Server as well.
ENGINE sets the storage engine that uses the tablespace, where
engine_name is the name of the storage engine. Currently, the values
InnoDB and NDB are supported. If not set, the value of
default_storage_engine is used. If it is not the same as the storage
engine used to create the tablespace, the DROP TABLESPACE statement
fails.
For an InnoDB tablespace, all tables must be dropped from the
tablespace prior to a DROP TABLESPACE operation. If the tablespace is
not empty, DROP TABLESPACE returns an error.
As with the InnoDB system tablespace, truncating or dropping InnoDB
tables stored in a general tablespace creates free space in the
tablespace .ibd data file, which can only be used for new InnoDB data.
Space is not released back to the operating system by such operations
as it is for file-per-table tablespaces.
An NDB tablespace to be dropped must not contain any data files; in
other words, before you can drop an NDB tablespace, you must first drop
each of its data files using ALTER TABLESPACE ... DROP DATAFILE.
Notes
o Tablespaces are not deleted automatically. A tablespace must be
dropped explicitly using DROP TABLESPACE. DROP DATABASE has no effect
in this regard, even if the operation drops all tables belonging to
the tablespace.
o A DROP DATABASE operation can drop tables that belong to a general
tablespace but it cannot drop the tablespace, even if the operation
drops all tables that belong to the tablespace. The tablespace must
be dropped explicitly using DROP TABLESPACE tablespace_name.
o Similar to the system tablespace, truncating or dropping tables
stored in a general tablespace creates free space internally in the
general tablespace .ibd data file which can only be used for new
InnoDB data. Space is not released back to the operating system as it
is for file-per-table tablespaces.
InnoDB Example
This example demonstrates how to drop an InnoDB general tablespace. The
general tablespace ts1 is created with a single table. Before dropping
the tablespace, the table must be dropped.
mysql> CREATE TABLESPACE `ts1` ADD DATAFILE 'ts1.ibd' Engine=InnoDB;
mysql> CREATE TABLE t1 (c1 INT PRIMARY KEY) TABLESPACE ts1 Engine=InnoDB;
mysql> DROP TABLE t1;
mysql> DROP TABLESPACE ts1;
NDB Example
This example shows how to drop an NDB tablespace myts having a data
file named mydata-1.dat after first creating the tablespace, and
assumes the existence of a log file group named mylg (see [HELP CREATE
LOGFILE GROUP]).
mysql> CREATE TABLESPACE myts
-> ADD DATAFILE 'mydata-1.dat'
-> USE LOGFILE GROUP mylg
-> ENGINE=NDB;
You must remove all data files from the tablespace using ALTER
TABLESPACE, as shown here, before it can be dropped:
mysql> ALTER TABLESPACE myts
-> DROP DATAFILE 'mydata-1.dat'
-> ENGINE=NDB;
mysql> DROP TABLESPACE myts;
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-tablespace.html
https://dev.mysql.com/doc/refman/5.7/en/drop-tablespace.html9 X�@ 0� "� 6 DROP TRIGGER &Syntax:
DROP TRIGGER [IF EXISTS] [schema_name.]trigger_name
This statement drops a trigger. The schema (database) name is optional.
If the schema is omitted, the trigger is dropped from the default
schema. DROP TRIGGER requires the TRIGGER privilege for the table
associated with the trigger.
Use IF EXISTS to prevent an error from occurring for a trigger that
does not exist. A NOTE is generated for a nonexistent trigger when
using IF EXISTS. See [HELP SHOW WARNINGS].
Triggers for a table are also dropped if you drop the table.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-trigger.html
https://dev.mysql.com/doc/refman/5.7/en/drop-trigger.html6 ��@ 80 "� 6 DROP VIEW &Syntax:
DROP VIEW [IF EXISTS]
view_name [, view_name] ...
[RESTRICT | CASCADE]
DROP VIEW removes one or more views. You must have the DROP privilege
for each view.
If any views named in the argument list do not exist, the statement
returns an error indicating by name which nonexisting views it was
unable to drop, but also drops all views in the list that do exist.
*Note*:
In MySQL 8.0, DROP VIEW fails if any views named in the argument list
do not exist. Due to the change in behavior, a partially completed DROP
VIEW operation on a MySQL 5.7 source fails when replicated to a MySQL
8.0 replica. To avoid this failure scenario, use IF EXISTS syntax in
DROP VIEW statements to prevent an error from occurring for views that
do not exist. For more information, see Atomic Data Definition
Statement Support
(https://dev.mysql.com/doc/refman/8.0/en/atomic-ddl.html).
The IF EXISTS clause prevents an error from occurring for views that
don't exist. When this clause is given, a NOTE is generated for each
nonexistent view. See [HELP SHOW WARNINGS].
RESTRICT and CASCADE, if given, are parsed and ignored.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-view.html
https://dev.mysql.com/doc/refman/5.7/en/drop-view.html9 ��@ @�^ "� 6 +RENAME TABLE &Syntax:
RENAME TABLE
tbl_name TO new_tbl_name
[, tbl_name2 TO new_tbl_name2] ...
RENAME TABLE renames one or more tables. You must have ALTER and DROP
privileges for the original table, and CREATE and INSERT privileges for
the new table.
For example, to rename a table named old_table to new_table, use this
statement:
RENAME TABLE old_table TO new_table;
That statement is equivalent to the following ALTER TABLE statement:
ALTER TABLE old_table RENAME new_table;
RENAME TABLE, unlike ALTER TABLE, can rename multiple tables within a
single statement:
RENAME TABLE old_table1 TO new_table1,
old_table2 TO new_table2,
old_table3 TO new_table3;
Renaming operations are performed left to right. Thus, to swap two
table names, do this (assuming that a table with the intermediary name
tmp_table does not already exist):
RENAME TABLE old_table TO tmp_table,
new_table TO old_table,
tmp_table TO new_table;
Metadata locks on tables are acquired in name order, which in some
cases can make a difference in operation outcome when multiple
transactions execute concurrently. See
https://dev.mysql.com/doc/refman/5.7/en/metadata-locking.html.
To execute RENAME TABLE, there must be no active transactions or tables
locked with LOCK TABLES. With the transaction table locking conditions
satisfied, the rename operation is done atomically; no other session
can access any of the tables while the rename is in progress.
If any errors occur during a RENAME TABLE, the statement fails and no
changes are made.
You can use RENAME TABLE to move a table from one database to another:
RENAME TABLE current_db.tbl_name TO other_db.tbl_name;
Using this method to move all tables from one database to a different
one in effect renames the database (an operation for which MySQL has no
single statement), except that the original database continues to
exist, albeit with no tables.
Like RENAME TABLE, ALTER TABLE ... RENAME can also be used to move a
table to a different database. Regardless of the statement used, if the
rename operation would move the table to a database located on a
different file system, the success of the outcome is platform specific
and depends on the underlying operating system calls used to move table
files.
If a table has triggers, attempts to rename the table into a different
database fail with a Trigger in wrong schema (ER_TRG_IN_WRONG_SCHEMA
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_trg_in_wrong_schema)) error.
To rename TEMPORARY tables, RENAME TABLE does not work. Use ALTER TABLE
instead.
RENAME TABLE works for views, except that views cannot be renamed into
a different database.
Any privileges granted specifically for a renamed table or view are not
migrated to the new name. They must be changed manually.
RENAME TABLE tbl_name TO new_tbl_name changes internally generated
foreign key constraint names and user-defined foreign key constraint
names that begin with the string "tbl_name_ibfk_" to reflect the new
table name. InnoDB interprets foreign key constraint names that begin
with the string "tbl_name_ibfk_" as internally generated names.
Foreign key constraint names that point to the renamed table are
automatically updated unless there is a conflict, in which case the
statement fails with an error. A conflict occurs if the renamed
constraint name already exists. In such cases, you must drop and
re-create the foreign keys for them to function properly.
URL: https://dev.mysql.com/doc/refman/5.7/en/rename-table.html
https://dev.mysql.com/doc/refman/5.7/en/rename-table.html p c:�Fu �9� G F H cE� 5��
1� infimum supremum; ��@ X
"� 6 8TRUNCATE TABLE &Syntax:
TRUNCATE [TABLE] tbl_name
TRUNCATE TABLE empties a table completely. It requires the DROP
privilege.
Logically, TRUNCATE TABLE is similar to a DELETE statement that deletes
all rows, or a sequence of DROP TABLE and CREATE TABLE statements. To
achieve high performance, it bypasses the DML method of deleting data.
Thus, it cannot be rolled back, it does not cause ON DELETE triggers to
fire, and it cannot be performed for InnoDB tables with parent-child
foreign key relationships.
Although TRUNCATE TABLE is similar to DELETE, it is classified as a DDL
statement rather than a DML statement. It differs from DELETE in the
following ways:
o Truncate operations drop and re-create the table, which is much
faster than deleting rows one by one, particularly for large tables.
o Truncate operations cause an implicit commit, and so cannot be rolled
back. See
https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
o Truncation operations cannot be performed if the session holds an
active table lock.
o TRUNCATE TABLE fails for an InnoDB table or NDB table if there are
any FOREIGN KEY constraints from other tables that reference the
table. Foreign key constraints between columns of the same table are
permitted.
o Truncation operations do not return a meaningful value for the number
of deleted rows. The usual result is "0 rows affected," which should
be interpreted as "no information."
o As long as the table format file tbl_name.frm is valid, the table can
be re-created as an empty table with TRUNCATE TABLE, even if the data
or index files have become corrupted.
o Any AUTO_INCREMENT value is reset to its start value. This is true
even for MyISAM and InnoDB, which normally do not reuse sequence
values.
o When used with partitioned tables, TRUNCATE TABLE preserves the
partitioning; that is, the data and index files are dropped and
re-created, while the partition definitions (.par) file is
unaffected.
o The TRUNCATE TABLE statement does not invoke ON DELETE triggers.
TRUNCATE TABLE is treated for purposes of binary logging and
replication as DDL rather than DML, and is always logged as a
statement.
URL: https://dev.mysql.com/doc/refman/5.7/en/truncate-table.html
https://dev.mysql.com/doc/refman/5.7/en/truncate-table.html1 ��@ "� 6 ECALL 'Syntax:
CALL sp_name([parameter[,...]])
CALL sp_name[()]
The CALL statement invokes a stored procedure that was defined
previously with CREATE PROCEDURE.
Stored procedures that take no arguments can be invoked without
parentheses. That is, CALL p() and CALL p are equivalent.
CALL can pass back values to its caller using parameters that are
declared as OUT or INOUT parameters. When the procedure returns, a
client program can also obtain the number of rows affected for the
final statement executed within the routine: At the SQL level, call the
ROW_COUNT() function; from the C API, call the mysql_affected_rows()
(https://dev.mysql.com/doc/c-api/5.7/en/mysql-affected-rows.html)
function.
For information about the effect of unhandled conditions on procedure
parameters, see
https://dev.mysql.com/doc/refman/5.7/en/conditions-and-parameters.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/call.html
https://dev.mysql.com/doc/refman/5.7/en/call.html3 �@ � "� 6 RDELETE 'Syntax:
DELETE is a DML statement that removes rows from a table.
Single-Table Syntax
DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[WHERE where_condition]
[ORDER BY ...]
[LIMIT row_count]
The DELETE statement deletes rows from tbl_name and returns the number
of deleted rows. To check the number of deleted rows, call the
ROW_COUNT() function described in
https://dev.mysql.com/doc/refman/5.7/en/information-functions.html.
Main Clauses
The conditions in the optional WHERE clause identify which rows to
delete. With no WHERE clause, all rows are deleted.
where_condition is an expression that evaluates to true for each row to
be deleted. It is specified as described in
https://dev.mysql.com/doc/refman/5.7/en/select.html.
If the ORDER BY clause is specified, the rows are deleted in the order
that is specified. The LIMIT clause places a limit on the number of
rows that can be deleted. These clauses apply to single-table deletes,
but not multi-table deletes.
Multiple-Table Syntax
DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
tbl_name[.*] [, tbl_name[.*]] ...
FROM table_references
[WHERE where_condition]
DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
FROM tbl_name[.*] [, tbl_name[.*]] ...
USING table_references
[WHERE where_condition]
Privileges
You need the DELETE privilege on a table to delete rows from it. You
need only the SELECT privilege for any columns that are only read, such
as those named in the WHERE clause.
Performance
When you do not need to know the number of deleted rows, the TRUNCATE
TABLE statement is a faster way to empty a table than a DELETE
statement with no WHERE clause. Unlike DELETE, TRUNCATE TABLE cannot be
used within a transaction or if you have a lock on the table. See [HELP
TRUNCATE TABLE] and [HELP LOCK TABLES].
The speed of delete operations may also be affected by factors
discussed in
https://dev.mysql.com/doc/refman/5.7/en/delete-optimization.html.
To ensure that a given DELETE statement does not take too much time,
the MySQL-specific LIMIT row_count clause for DELETE specifies the
maximum number of rows to be deleted. If the number of rows to delete
is larger than the limit, repeat the DELETE statement until the number
of affected rows is less than the LIMIT value.
Subqueries
You cannot delete from a table and select from the same table in a
subquery.
Partitioned Table Support
DELETE supports explicit partition selection using the PARTITION
clause, which takes a list of the comma-separated names of one or more
partitions or subpartitions (or both) from which to select rows to be
dropped. Partitions not included in the list are ignored. Given a
partitioned table t with a partition named p0, executing the statement
DELETE FROM t PARTITION (p0) has the same effect on the table as
executing ALTER TABLE t TRUNCATE PARTITION (p0); in both cases, all
rows in partition p0 are dropped.
PARTITION can be used along with a WHERE condition, in which case the
condition is tested only on rows in the listed partitions. For example,
DELETE FROM t PARTITION (p0) WHERE c < 5 deletes rows only from
partition p0 for which the condition c < 5 is true; rows in any other
partitions are not checked and thus not affected by the DELETE.
The PARTITION clause can also be used in multiple-table DELETE
statements. You can use up to one such option per table named in the
FROM option.
For more information and examples, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/delete.html
https://dev.mysql.com/doc/refman/5.7/en/delete.html/ @ (N
"� 6 _DO 'Syntax:
DO expr [, expr] ...
DO executes the expressions but does not return any results. In most
respects, DO is shorthand for SELECT expr, ..., but has the advantage
that it is slightly faster when you do not care about the result.
DO is useful primarily with functions that have side effects, such as
RELEASE_LOCK().
Example: This SELECT statement pauses, but also produces a result set:
mysql> SELECT SLEEP(5);
+----------+
| SLEEP(5) |
+----------+
| 0 |
+----------+
1 row in set (5.02 sec)
DO, on the other hand, pauses without producing a result set.:
mysql> DO SLEEP(5);
Query OK, 0 rows affected (4.99 sec)
This could be useful, for example in a stored function or trigger,
which prohibit statements that produce result sets.
DO only executes expressions. It cannot be used in all cases where
SELECT can be used. For example, DO id FROM t1 is invalid because it
references a table.
URL: https://dev.mysql.com/doc/refman/5.7/en/do.html
https://dev.mysql.com/doc/refman/5.7/en/do.html4 6�@ 0� "� 6 lHANDLER 'Syntax:
HANDLER tbl_name OPEN [ [AS] alias]
HANDLER tbl_name READ index_name { = | <= | >= | < | > } (value1,value2,...)
[ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ index_name { FIRST | NEXT | PREV | LAST }
[ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ { FIRST | NEXT }
[ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name CLOSE
The HANDLER statement provides direct access to table storage engine
interfaces. It is available for InnoDB and MyISAM tables.
URL: https://dev.mysql.com/doc/refman/5.7/en/handler.html
https://dev.mysql.com/doc/refman/5.7/en/handler.html3 S�@ 8
� "� 6 yINSERT 'Syntax:
INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[(col_name [, col_name] ...)]
{VALUES | VALUE} (value_list) [, (value_list)] ...
[ON DUPLICATE KEY UPDATE assignment_list]
INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
SET assignment_list
[ON DUPLICATE KEY UPDATE assignment_list]
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[(col_name [, col_name] ...)]
SELECT ...
[ON DUPLICATE KEY UPDATE assignment_list]
value:
{expr | DEFAULT}
value_list:
value [, value] ...
assignment:
col_name = value
assignment_list:
assignment [, assignment] ...
INSERT inserts new rows into an existing table. The INSERT ... VALUES
and INSERT ... SET forms of the statement insert rows based on
explicitly specified values. The INSERT ... SELECT form inserts rows
selected from another table or tables. INSERT with an ON DUPLICATE KEY
UPDATE clause enables existing rows to be updated if a row to be
inserted would cause a duplicate value in a UNIQUE index or PRIMARY
KEY.
For additional information about INSERT ... SELECT and INSERT ... ON
DUPLICATE KEY UPDATE, see [HELP INSERT SELECT], and
https://dev.mysql.com/doc/refman/5.7/en/insert-on-duplicate.html.
In MySQL 5.7, the DELAYED keyword is accepted but ignored by the
server. For the reasons for this, see [HELP INSERT DELAYED],
Inserting into a table requires the INSERT privilege for the table. If
the ON DUPLICATE KEY UPDATE clause is used and a duplicate key causes
an UPDATE to be performed instead, the statement requires the UPDATE
privilege for the columns to be updated. For columns that are read but
not modified you need only the SELECT privilege (such as for a column
referenced only on the right hand side of an col_name=expr assignment
in an ON DUPLICATE KEY UPDATE clause).
When inserting into a partitioned table, you can control which
partitions and subpartitions accept new rows. The PARTITION clause
takes a list of the comma-separated names of one or more partitions or
subpartitions (or both) of the table. If any of the rows to be inserted
by a given INSERT statement do not match one of the partitions listed,
the INSERT statement fails with the error Found a row not matching the
given partition set. For more information and examples, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/insert.html
https://dev.mysql.com/doc/refman/5.7/en/insert.html: ��@ @H "� 6 �INSERT SELECT 'Syntax:
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[(col_name [, col_name] ...)]
SELECT ...
[ON DUPLICATE KEY UPDATE assignment_list]
value:
{expr | DEFAULT}
assignment:
col_name = value
assignment_list:
assignment [, assignment] ...
With INSERT ... SELECT, you can quickly insert many rows into a table
from the result of a SELECT statement, which can select from one or
many tables. For example:
INSERT INTO tbl_temp2 (fld_id)
SELECT tbl_temp1.fld_order_id
FROM tbl_temp1 WHERE tbl_temp1.fld_order_id > 100;
URL: https://dev.mysql.com/doc/refman/5.7/en/insert-select.html
https://dev.mysql.com/doc/refman/5.7/en/insert-select.html; J�@ HΌ "� 6 �INSERT DELAYED 'Syntax:
INSERT DELAYED ...
The DELAYED option for the INSERT statement is a MySQL extension to
standard SQL. In previous versions of MySQL, it can be used for certain
kinds of tables (such as MyISAM), such that when a client uses INSERT
DELAYED, it gets an okay from the server at once, and the row is queued
to be inserted when the table is not in use by any other thread.
DELAYED inserts and replaces were deprecated in MySQL 5.6. In MySQL
5.7, DELAYED is not supported. The server recognizes but ignores the
DELAYED keyword, handles the insert as a nondelayed insert, and
generates an ER_WARN_LEGACY_SYNTAX_CONVERTED warning: INSERT DELAYED is
no longer supported. The statement was converted to INSERT. The DELAYED
keyword is scheduled for removal in a future release.
URL: https://dev.mysql.com/doc/refman/5.7/en/insert-delayed.html
https://dev.mysql.com/doc/refman/5.7/en/insert-delayed.html p � c�9� c��� H G I ��E� ;^� -{ infimum supremum6 <�@ � "� 6 �LOAD DATA 'Syntax:
LOAD DATA
[LOW_PRIORITY | CONCURRENT] [LOCAL]
INFILE 'file_name'
[REPLACE | IGNORE]
INTO TABLE tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[CHARACTER SET charset_name]
[{FIELDS | COLUMNS}
[TERMINATED BY 'string']
[[OPTIONALLY] ENCLOSED BY 'char']
[ESCAPED BY 'char']
]
[LINES
[STARTING BY 'string']
[TERMINATED BY 'string']
]
[IGNORE number {LINES | ROWS}]
[(col_name_or_user_var
[, col_name_or_user_var] ...)]
[SET col_name={expr | DEFAULT}
[, col_name={expr | DEFAULT}] ...]
The LOAD DATA statement reads rows from a text file into a table at a
very high speed. The file can be read from the server host or the
client host, depending on whether the LOCAL modifier is given. LOCAL
also affects data interpretation and error handling.
LOAD DATA is the complement of SELECT ... INTO OUTFILE. (See
https://dev.mysql.com/doc/refman/5.7/en/select-into.html.) To write
data from a table to a file, use SELECT ... INTO OUTFILE. To read the
file back into a table, use LOAD DATA. The syntax of the FIELDS and
LINES clauses is the same for both statements.
The mysqlimport utility provides another way to load data files; it
operates by sending a LOAD DATA statement to the server. See
https://dev.mysql.com/doc/refman/5.7/en/mysqlimport.html.
For information about the efficiency of INSERT versus LOAD DATA and
speeding up LOAD DATA, see
https://dev.mysql.com/doc/refman/5.7/en/insert-optimization.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/load-data.html
https://dev.mysql.com/doc/refman/5.7/en/load-data.html5 ��@ 2 "� 6 �LOAD XML 'Syntax:
LOAD XML
[LOW_PRIORITY | CONCURRENT] [LOCAL]
INFILE 'file_name'
[REPLACE | IGNORE]
INTO TABLE [db_name.]tbl_name
[CHARACTER SET charset_name]
[ROWS IDENTIFIED BY '<tagname>']
[IGNORE number {LINES | ROWS}]
[(field_name_or_user_var
[, field_name_or_user_var] ...)]
[SET col_name={expr | DEFAULT}
[, col_name={expr | DEFAULT}] ...]
The LOAD XML statement reads data from an XML file into a table. The
file_name must be given as a literal string. The tagname in the
optional ROWS IDENTIFIED BY clause must also be given as a literal
string, and must be surrounded by angle brackets (< and >).
LOAD XML acts as the complement of running the mysql client in XML
output mode (that is, starting the client with the --xml option). To
write data from a table to an XML file, you can invoke the mysql client
with the --xml and -e options from the system shell, as shown here:
$> mysql --xml -e 'SELECT * FROM mydb.mytable' > file.xml
To read the file back into a table, use LOAD XML. By default, the <row>
element is considered to be the equivalent of a database table row;
this can be changed using the ROWS IDENTIFIED BY clause.
This statement supports three different XML formats:
o Column names as attributes and column values as attribute values:
<row column1="value1" column2="value2" .../>
o Column names as tags and column values as the content of these tags:
<row>
<column1>value1</column1>
<column2>value2</column2>
</row>
o Column names are the name attributes of <field> tags, and values are
the contents of these tags:
<row>
<field name='column1'>value1</field>
<field name='column2'>value2</field>
</row>
This is the format used by other MySQL tools, such as mysqldump.
All three formats can be used in the same XML file; the import routine
automatically detects the format for each row and interprets it
correctly. Tags are matched based on the tag or attribute name and the
column name.
In MySQL 5.7, LOAD XML does not support CDATA sections in the source
XML. This limitation is removed in MySQL 8.0. (Bug #30753708, Bug
#98199)
The following clauses work essentially the same way for LOAD XML as
they do for LOAD DATA:
o LOW_PRIORITY or CONCURRENT
o LOCAL
o REPLACE or IGNORE
o CHARACTER SET
o SET
See [HELP LOAD DATA], for more information about these clauses.
(field_name_or_user_var, ...) is a list of one or more comma-separated
XML fields or user variables. The name of a user variable used for this
purpose must match the name of a field from the XML file, prefixed with
@. You can use field names to select only desired fields. User
variables can be employed to store the corresponding field values for
subsequent re-use.
The IGNORE number LINES or IGNORE number ROWS clause causes the first
number rows in the XML file to be skipped. It is analogous to the LOAD
DATA statement's IGNORE ... LINES clause.
URL: https://dev.mysql.com/doc/refman/5.7/en/load-xml.html
https://dev.mysql.com/doc/refman/5.7/en/load-xml.html4 Nj@ X "� 6 �REPLACE 'Syntax:
REPLACE [LOW_PRIORITY | DELAYED]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[(col_name [, col_name] ...)]
{VALUES | VALUE} (value_list) [, (value_list)] ...
REPLACE [LOW_PRIORITY | DELAYED]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
SET assignment_list
REPLACE [LOW_PRIORITY | DELAYED]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[(col_name [, col_name] ...)]
SELECT ...
value:
{expr | DEFAULT}
value_list:
value [, value] ...
assignment:
col_name = value
assignment_list:
assignment [, assignment] ...
REPLACE works exactly like INSERT, except that if an old row in the
table has the same value as a new row for a PRIMARY KEY or a UNIQUE
index, the old row is deleted before the new row is inserted. See [HELP
INSERT].
REPLACE is a MySQL extension to the SQL standard. It either inserts, or
deletes and inserts. For another MySQL extension to standard SQL---that
either inserts or updates---see
https://dev.mysql.com/doc/refman/5.7/en/insert-on-duplicate.html.
DELAYED inserts and replaces were deprecated in MySQL 5.6. In MySQL
5.7, DELAYED is not supported. The server recognizes but ignores the
DELAYED keyword, handles the replace as a nondelayed replace, and
generates an ER_WARN_LEGACY_SYNTAX_CONVERTED warning: REPLACE DELAYED
is no longer supported. The statement was converted to REPLACE. The
DELAYED keyword is scheduled for removal in a future release. release.
*Note*:
REPLACE makes sense only if a table has a PRIMARY KEY or UNIQUE index.
Otherwise, it becomes equivalent to INSERT, because there is no index
to be used to determine whether a new row duplicates another.
Values for all columns are taken from the values specified in the
REPLACE statement. Any missing columns are set to their default values,
just as happens for INSERT. You cannot refer to values from the current
row and use them in the new row. If you use an assignment such as SET
col_name = col_name + 1, the reference to the column name on the right
hand side is treated as DEFAULT(col_name), so the assignment is
equivalent to SET col_name = DEFAULT(col_name) + 1.
To use REPLACE, you must have both the INSERT and DELETE privileges for
the table.
If a generated column is replaced explicitly, the only permitted value
is DEFAULT. For information about generated columns, see
https://dev.mysql.com/doc/refman/5.7/en/create-table-generated-columns.
html.
REPLACE supports explicit partition selection using the PARTITION
clause with a list of comma-separated names of partitions,
subpartitions, or both. As with INSERT, if it is not possible to insert
the new row into any of these partitions or subpartitions, the REPLACE
statement fails with the error Found a row not matching the given
partition set. For more information and examples, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/replace.html
https://dev.mysql.com/doc/refman/5.7/en/replace.html3 Ԋ@ ( d "� 6 �SELECT 'Syntax:
SELECT
[ALL | DISTINCT | DISTINCTROW ]
[HIGH_PRIORITY]
[STRAIGHT_JOIN]
[SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
[SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
select_expr [, select_expr] ...
[into_option]
[FROM table_references
[PARTITION partition_list]]
[WHERE where_condition]
[GROUP BY {col_name | expr | position}
[ASC | DESC], ... [WITH ROLLUP]]
[HAVING where_condition]
[ORDER BY {col_name | expr | position}
[ASC | DESC], ...]
[LIMIT {[offset,] row_count | row_count OFFSET offset}]
[PROCEDURE procedure_name(argument_list)]
[into_option]
[FOR UPDATE | LOCK IN SHARE MODE]
into_option: {
INTO OUTFILE 'file_name'
[CHARACTER SET charset_name]
export_options
| INTO DUMPFILE 'file_name'
| INTO var_name [, var_name] ...
}
SELECT is used to retrieve rows selected from one or more tables, and
can include UNION statements and subqueries. See [HELP UNION], and
https://dev.mysql.com/doc/refman/5.7/en/subqueries.html.
The most commonly used clauses of SELECT statements are these:
o Each select_expr indicates a column that you want to retrieve. There
must be at least one select_expr.
o table_references indicates the table or tables from which to retrieve
rows. Its syntax is described in [HELP JOIN].
o SELECT supports explicit partition selection using the PARTITION
clause with a list of partitions or subpartitions (or both) following
the name of the table in a table_reference (see [HELP JOIN]). In this
case, rows are selected only from the partitions listed, and any
other partitions of the table are ignored. For more information and
examples, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
SELECT ... PARTITION from tables using storage engines such as MyISAM
that perform table-level locks (and thus partition locks) lock only
the partitions or subpartitions named by the PARTITION option.
For more information, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-limitations-lock
ing.html.
o The WHERE clause, if given, indicates the condition or conditions
that rows must satisfy to be selected. where_condition is an
expression that evaluates to true for each row to be selected. The
statement selects all rows if there is no WHERE clause.
In the WHERE expression, you can use any of the functions and
operators that MySQL supports, except for aggregate (group)
functions. See
https://dev.mysql.com/doc/refman/5.7/en/expressions.html, and
https://dev.mysql.com/doc/refman/5.7/en/functions.html.
SELECT can also be used to retrieve rows computed without reference to
any table.
URL: https://dev.mysql.com/doc/refman/5.7/en/select.html
https://dev.mysql.com/doc/refman/5.7/en/select.html3 ��@ 0< "� 6 �DUAL 'You are permitted to specify DUAL as a dummy table name in situations
where no tables are referenced:
mysql> SELECT 1 + 1 FROM DUAL;
-> 2
DUAL is purely for the convenience of people who require that all
SELECT statements should have FROM and possibly other clauses. MySQL
may ignore the clauses. MySQL does not require FROM DUAL if no tables
are referenced.
URL: https://dev.mysql.com/doc/refman/5.7/en/select.html
https://dev.mysql.com/doc/refman/5.7/en/select.html1r�@ 8� "� 6 �JOIN 'MySQL supports the following JOIN syntax for the table_references part
of SELECT statements and multiple-table DELETE and UPDATE statements:
table_references:
escaped_table_reference [, escaped_table_reference] ...
escaped_table_reference: {
table_reference
| { OJ table_reference }
}
table_reference: {
table_factor
| joined_table
}
table_factor: {
tbl_name [PARTITION (partition_names)]
[[AS] alias] [index_hint_list]
| table_subquery [AS] alias
| ( table_references )
}
joined_table: {
table_reference [INNER | CROSS] JOIN table_factor [join_specification]
| table_reference STRAIGHT_JOIN table_factor
| table_reference STRAIGHT_JOIN table_factor ON search_condition
| table_reference {LEFT|RIGHT} [OUTER] JOIN table_reference join_specification
| table_reference NATURAL [{LEFT|RIGHT} [OUTER]] JOIN table_factor
}
join_specification: {
ON search_condition
| USING (join_column_list)
}
join_column_list:
column_name [, column_name] ...
index_hint_list:
index_hint [, index_hint] ...
index_hint: {
USE {INDEX|KEY}
[FOR {JOIN|ORDER BY|GROUP BY}] ([index_list])
| {IGNORE|FORCE} {INDEX|KEY}
[FOR {JOIN|ORDER BY|GROUP BY}] (index_list)
}
index_list:
index_name [, index_name] ...
A table reference is also known as a join expression.
A table reference (when it refers to a partitioned table) may contain a
PARTITION clause, including a list of comma-separated partitions,
subpartitions, or both. This option follows the name of the table and
precedes any alias declaration. The effect of this option is that rows
are selected only from the listed partitions or subpartitions. Any
partitions or subpartitions not named in the list are ignored. For more
information and examples, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
The syntax of table_factor is extended in MySQL in comparison with
standard SQL. The standard accepts only table_reference, not a list of
them inside a pair of parentheses.
This is a conservative extension if each comma in a list of
table_reference items is considered as equivalent to an inner join. For
example:
SELECT * FROM t1 LEFT JOIN (t2, t3, t4)
ON (t2.a = t1.a AND t3.b = t1.b AND t4.c = t1.c)
is equivalent to:
SELECT * FROM t1 LEFT JOIN (t2 CROSS JOIN t3 CROSS JOIN t4)
ON (t2.a = t1.a AND t3.b = t1.b AND t4.c = t1.c)
In MySQL, JOIN, CROSS JOIN, and INNER JOIN are syntactic equivalents
(they can replace each other). In standard SQL, they are not
equivalent. INNER JOIN is used with an ON clause, CROSS JOIN is used
otherwise.
In general, parentheses can be ignored in join expressions containing
only inner join operations. MySQL also supports nested joins. See
https://dev.mysql.com/doc/refman/5.7/en/nested-join-optimization.html.
Index hints can be specified to affect how the MySQL optimizer makes
use of indexes. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/index-hints.html. Optimizer
hints and the optimizer_switch system variable are other ways to
influence optimizer use of indexes. See
https://dev.mysql.com/doc/refman/5.7/en/optimizer-hints.html, and
https://dev.mysql.com/doc/refman/5.7/en/switchable-optimizations.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/join.html
SELECT left_tbl.*
FROM left_tbl LEFT JOIN right_tbl ON left_tbl.id = right_tbl.id
WHERE right_tbl.id IS NULL;
https://dev.mysql.com/doc/refman/5.7/en/join.html p c��� ��^�� I H J ��E� %~� � infimum supremum2 ��@ 7 "� 6 �UNION 'Syntax:
SELECT ...
UNION [ALL | DISTINCT] SELECT ...
[UNION [ALL | DISTINCT] SELECT ...]
UNION combines the result from multiple SELECT statements into a single
result set. Example:
mysql> SELECT 1, 2;
+---+---+
| 1 | 2 |
+---+---+
| 1 | 2 |
+---+---+
mysql> SELECT 'a', 'b';
+---+---+
| a | b |
+---+---+
| a | b |
+---+---+
mysql> SELECT 1, 2 UNION SELECT 'a', 'b';
+---+---+
| 1 | 2 |
+---+---+
| 1 | 2 |
| a | b |
+---+---+
o https://dev.mysql.com/doc/refman/5.7/en/union.html#union-result-set
o https://dev.mysql.com/doc/refman/5.7/en/union.html#union-distinct-all
o https://dev.mysql.com/doc/refman/5.7/en/union.html#union-order-by-lim
it
o https://dev.mysql.com/doc/refman/5.7/en/union.html#union-restrictions
Result Set Column Names and Data Types
The column names for a UNION result set are taken from the column names
of the first SELECT statement.
Selected columns listed in corresponding positions of each SELECT
statement should have the same data type. For example, the first column
selected by the first statement should have the same type as the first
column selected by the other statements. If the data types of
corresponding SELECT columns do not match, the types and lengths of the
columns in the UNION result take into account the values retrieved by
all the SELECT statements. For example, consider the following, where
the column length is not constrained to the length of the value from
the first SELECT:
mysql> SELECT REPEAT('a',1) UNION SELECT REPEAT('b',20);
+----------------------+
| REPEAT('a',1) |
+----------------------+
| a |
| bbbbbbbbbbbbbbbbbbbb |
+----------------------+
UNION DISTINCT and UNION ALL
By default, duplicate rows are removed from UNION results. The optional
DISTINCT keyword has the same effect but makes it explicit. With the
optional ALL keyword, duplicate-row removal does not occur and the
result includes all matching rows from all the SELECT statements.
You can mix UNION ALL and UNION DISTINCT in the same query. Mixed UNION
types are treated such that a DISTINCT union overrides any ALL union to
its left. A DISTINCT union can be produced explicitly by using UNION
DISTINCT or implicitly by using UNION with no following DISTINCT or ALL
keyword.
ORDER BY and LIMIT in Unions
To apply an ORDER BY or LIMIT clause to an individual SELECT,
parenthesize the SELECT and place the clause inside the parentheses:
(SELECT a FROM t1 WHERE a=10 AND B=1 ORDER BY a LIMIT 10)
UNION
(SELECT a FROM t2 WHERE a=11 AND B=2 ORDER BY a LIMIT 10);
*Note*:
Previous versions of MySQL may permit such statements without
parentheses. In MySQL 5.7, the requirement for parentheses is enforced.
Use of ORDER BY for individual SELECT statements implies nothing about
the order in which the rows appear in the final result because UNION by
default produces an unordered set of rows. Therefore, ORDER BY in this
context typically is used in conjunction with LIMIT, to determine the
subset of the selected rows to retrieve for the SELECT, even though it
does not necessarily affect the order of those rows in the final UNION
result. If ORDER BY appears without LIMIT in a SELECT, it is optimized
away because it has no effect.
To use an ORDER BY or LIMIT clause to sort or limit the entire UNION
result, parenthesize the individual SELECT statements and place the
ORDER BY or LIMIT after the last one:
(SELECT a FROM t1 WHERE a=10 AND B=1)
UNION
(SELECT a FROM t2 WHERE a=11 AND B=2)
ORDER BY a LIMIT 10;
A statement without parentheses is equivalent to one parenthesized as
just shown.
This kind of ORDER BY cannot use column references that include a table
name (that is, names in tbl_name.col_name format). Instead, provide a
column alias in the first SELECT statement and refer to the alias in
the ORDER BY. (Alternatively, refer to the column in the ORDER BY using
its column position. However, use of column positions is deprecated.)
Also, if a column to be sorted is aliased, the ORDER BY clause must
refer to the alias, not the column name. The first of the following
statements is permitted, but the second fails with an Unknown column
'a' in 'order clause' error:
(SELECT a AS b FROM t) UNION (SELECT ...) ORDER BY b;
(SELECT a AS b FROM t) UNION (SELECT ...) ORDER BY a;
To cause rows in a UNION result to consist of the sets of rows
retrieved by each SELECT one after the other, select an additional
column in each SELECT to use as a sort column and add an ORDER BY that
sorts on that column following the last SELECT:
(SELECT 1 AS sort_col, col1a, col1b, ... FROM t1)
UNION
(SELECT 2, col2a, col2b, ... FROM t2) ORDER BY sort_col;
To additionally maintain sort order within individual SELECT results,
add a secondary column to the ORDER BY clause:
(SELECT 1 AS sort_col, col1a, col1b, ... FROM t1)
UNION
(SELECT 2, col2a, col2b, ... FROM t2) ORDER BY sort_col, col1a;
Use of an additional column also enables you to determine which SELECT
each row comes from. Extra columns can provide other identifying
information as well, such as a string that indicates a table name.
UNION queries with an aggregate function in an ORDER BY clause are
rejected with an ER_AGGREGATE_ORDER_FOR_UNION
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_aggregate_order_for_union) error. Example:
SELECT 1 AS foo UNION SELECT 2 ORDER BY MAX(1);
UNION Restrictions
In a UNION, the SELECT statements are normal select statements, but
with the following restrictions:
o HIGH_PRIORITY in the first SELECT has no effect. HIGH_PRIORITY in any
subsequent SELECT produces a syntax error.
o Only the last SELECT statement can use an INTO clause. However, the
entire UNION result is written to the INTO output destination.
URL: https://dev.mysql.com/doc/refman/5.7/en/union.html
https://dev.mysql.com/doc/refman/5.7/en/union.html3 ?�@ � "� 6 �UPDATE 'Syntax:
UPDATE is a DML statement that modifies rows in a table.
Single-table syntax:
UPDATE [LOW_PRIORITY] [IGNORE] table_reference
SET assignment_list
[WHERE where_condition]
[ORDER BY ...]
[LIMIT row_count]
value:
{expr | DEFAULT}
assignment:
col_name = value
assignment_list:
assignment [, assignment] ...
Multiple-table syntax:
UPDATE [LOW_PRIORITY] [IGNORE] table_references
SET assignment_list
[WHERE where_condition]
For the single-table syntax, the UPDATE statement updates columns of
existing rows in the named table with new values. The SET clause
indicates which columns to modify and the values they should be given.
Each value can be given as an expression, or the keyword DEFAULT to set
a column explicitly to its default value. The WHERE clause, if given,
specifies the conditions that identify which rows to update. With no
WHERE clause, all rows are updated. If the ORDER BY clause is
specified, the rows are updated in the order that is specified. The
LIMIT clause places a limit on the number of rows that can be updated.
For the multiple-table syntax, UPDATE updates rows in each table named
in table_references that satisfy the conditions. Each matching row is
updated once, even if it matches the conditions multiple times. For
multiple-table syntax, ORDER BY and LIMIT cannot be used.
For partitioned tables, both the single-single and multiple-table forms
of this statement support the use of a PARTITION clause as part of a
table reference. This option takes a list of one or more partitions or
subpartitions (or both). Only the partitions (or subpartitions) listed
are checked for matches, and a row that is not in any of these
partitions or subpartitions is not updated, whether it satisfies the
where_condition or not.
*Note*:
Unlike the case when using PARTITION with an INSERT or REPLACE
statement, an otherwise valid UPDATE ... PARTITION statement is
considered successful even if no rows in the listed partitions (or
subpartitions) match the where_condition.
For more information and examples, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
where_condition is an expression that evaluates to true for each row to
be updated. For expression syntax, see
https://dev.mysql.com/doc/refman/5.7/en/expressions.html.
table_references and where_condition are specified as described in
https://dev.mysql.com/doc/refman/5.7/en/select.html.
You need the UPDATE privilege only for columns referenced in an UPDATE
that are actually updated. You need only the SELECT privilege for any
columns that are read but not modified.
The UPDATE statement supports the following modifiers:
o With the LOW_PRIORITY modifier, execution of the UPDATE is delayed
until no other clients are reading from the table. This affects only
storage engines that use only table-level locking (such as MyISAM,
MEMORY, and MERGE).
o With the IGNORE modifier, the update statement does not abort even if
errors occur during the update. Rows for which duplicate-key
conflicts occur on a unique key value are not updated. Rows updated
to values that would cause data conversion errors are updated to the
closest valid values instead. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#ignore-effect-o
n-execution.
URL: https://dev.mysql.com/doc/refman/5.7/en/update.html
https://dev.mysql.com/doc/refman/5.7/en/update.html p c�^�� ����� J I K ��E� 3P� � infimum supremum3 ܘ@ l "� 6 START TRANSACTION (Syntax:
START TRANSACTION
[transaction_characteristic [, transaction_characteristic] ...]
transaction_characteristic: {
WITH CONSISTENT SNAPSHOT
| READ WRITE
| READ ONLY
}
BEGIN [WORK]
COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
SET autocommit = {0 | 1}
These statements provide control over use of transactions:
o START TRANSACTION or BEGIN start a new transaction.
o COMMIT commits the current transaction, making its changes permanent.
o ROLLBACK rolls back the current transaction, canceling its changes.
o SET autocommit disables or enables the default autocommit mode for
the current session.
By default, MySQL runs with autocommit mode enabled. This means that,
when not otherwise inside a transaction, each statement is atomic, as
if it were surrounded by START TRANSACTION and COMMIT. You cannot use
ROLLBACK to undo the effect; however, if an error occurs during
statement execution, the statement is rolled back.
To disable autocommit mode implicitly for a single series of
statements, use the START TRANSACTION statement:
START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summary=@A WHERE type=1;
COMMIT;
With START TRANSACTION, autocommit remains disabled until you end the
transaction with COMMIT or ROLLBACK. The autocommit mode then reverts
to its previous state.
START TRANSACTION permits several modifiers that control transaction
characteristics. To specify multiple modifiers, separate them by
commas.
o The WITH CONSISTENT SNAPSHOT modifier starts a consistent read for
storage engines that are capable of it. This applies only to InnoDB.
The effect is the same as issuing a START TRANSACTION followed by a
SELECT from any InnoDB table. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-consistent-read.html.
The WITH CONSISTENT SNAPSHOT modifier does not change the current
transaction isolation level, so it provides a consistent snapshot
only if the current isolation level is one that permits a consistent
read. The only isolation level that permits a consistent read is
REPEATABLE READ. For all other isolation levels, the WITH CONSISTENT
SNAPSHOT clause is ignored. As of MySQL 5.7.2, a warning is generated
when the WITH CONSISTENT SNAPSHOT clause is ignored.
o The READ WRITE and READ ONLY modifiers set the transaction access
mode. They permit or prohibit changes to tables used in the
transaction. The READ ONLY restriction prevents the transaction from
modifying or locking both transactional and nontransactional tables
that are visible to other transactions; the transaction can still
modify or lock temporary tables.
MySQL enables extra optimizations for queries on InnoDB tables when
the transaction is known to be read-only. Specifying READ ONLY
ensures these optimizations are applied in cases where the read-only
status cannot be determined automatically. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-performance-ro-txn.htm
l for more information.
If no access mode is specified, the default mode applies. Unless the
default has been changed, it is read/write. It is not permitted to
specify both READ WRITE and READ ONLY in the same statement.
In read-only mode, it remains possible to change tables created with
the TEMPORARY keyword using DML statements. Changes made with DDL
statements are not permitted, just as with permanent tables.
For additional information about transaction access mode, including
ways to change the default mode, see [HELP SET TRANSACTION].
If the read_only system variable is enabled, explicitly starting a
transaction with START TRANSACTION READ WRITE requires the SUPER
privilege.
*Important*:
Many APIs used for writing MySQL client applications (such as JDBC)
provide their own methods for starting transactions that can (and
sometimes should) be used instead of sending a START TRANSACTION
statement from the client. See
https://dev.mysql.com/doc/refman/5.7/en/connectors-apis.html, or the
documentation for your API, for more information.
To disable autocommit mode explicitly, use the following statement:
SET autocommit=0;
After disabling autocommit mode by setting the autocommit variable to
zero, changes to transaction-safe tables (such as those for InnoDB or
NDB) are not made permanent immediately. You must use COMMIT to store
your changes to disk or ROLLBACK to ignore the changes.
autocommit is a session variable and must be set for each session. To
disable autocommit mode for each new connection, see the description of
the autocommit system variable at
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
BEGIN and BEGIN WORK are supported as aliases of START TRANSACTION for
initiating a transaction. START TRANSACTION is standard SQL syntax, is
the recommended way to start an ad-hoc transaction, and permits
modifiers that BEGIN does not.
The BEGIN statement differs from the use of the BEGIN keyword that
starts a BEGIN ... END compound statement. The latter does not begin a
transaction. See [HELP BEGIN END].
*Note*:
Within all stored programs (stored procedures and functions, triggers,
and events), the parser treats BEGIN [WORK] as the beginning of a BEGIN
... END block. Begin a transaction in this context with START
TRANSACTION instead.
The optional WORK keyword is supported for COMMIT and ROLLBACK, as are
the CHAIN and RELEASE clauses. CHAIN and RELEASE can be used for
additional control over transaction completion. The value of the
completion_type system variable determines the default completion
behavior. See
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
The AND CHAIN clause causes a new transaction to begin as soon as the
current one ends, and the new transaction has the same isolation level
as the just-terminated transaction. The new transaction also uses the
same access mode (READ WRITE or READ ONLY) as the just-terminated
transaction. The RELEASE clause causes the server to disconnect the
current client session after terminating the current transaction.
Including the NO keyword suppresses CHAIN or RELEASE completion, which
can be useful if the completion_type system variable is set to cause
chaining or release completion by default.
URL: https://dev.mysql.com/doc/refman/5.7/en/commit.html
https://dev.mysql.com/doc/refman/5.7/en/commit.html3 ܘ@ � "� 6 BEGIN (Syntax:
START TRANSACTION
[transaction_characteristic [, transaction_characteristic] ...]
transaction_characteristic: {
WITH CONSISTENT SNAPSHOT
| READ WRITE
| READ ONLY
}
BEGIN [WORK]
COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
SET autocommit = {0 | 1}
These statements provide control over use of transactions:
o START TRANSACTION or BEGIN start a new transaction.
o COMMIT commits the current transaction, making its changes permanent.
o ROLLBACK rolls back the current transaction, canceling its changes.
o SET autocommit disables or enables the default autocommit mode for
the current session.
By default, MySQL runs with autocommit mode enabled. This means that,
when not otherwise inside a transaction, each statement is atomic, as
if it were surrounded by START TRANSACTION and COMMIT. You cannot use
ROLLBACK to undo the effect; however, if an error occurs during
statement execution, the statement is rolled back.
To disable autocommit mode implicitly for a single series of
statements, use the START TRANSACTION statement:
START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summary=@A WHERE type=1;
COMMIT;
With START TRANSACTION, autocommit remains disabled until you end the
transaction with COMMIT or ROLLBACK. The autocommit mode then reverts
to its previous state.
START TRANSACTION permits several modifiers that control transaction
characteristics. To specify multiple modifiers, separate them by
commas.
o The WITH CONSISTENT SNAPSHOT modifier starts a consistent read for
storage engines that are capable of it. This applies only to InnoDB.
The effect is the same as issuing a START TRANSACTION followed by a
SELECT from any InnoDB table. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-consistent-read.html.
The WITH CONSISTENT SNAPSHOT modifier does not change the current
transaction isolation level, so it provides a consistent snapshot
only if the current isolation level is one that permits a consistent
read. The only isolation level that permits a consistent read is
REPEATABLE READ. For all other isolation levels, the WITH CONSISTENT
SNAPSHOT clause is ignored. As of MySQL 5.7.2, a warning is generated
when the WITH CONSISTENT SNAPSHOT clause is ignored.
o The READ WRITE and READ ONLY modifiers set the transaction access
mode. They permit or prohibit changes to tables used in the
transaction. The READ ONLY restriction prevents the transaction from
modifying or locking both transactional and nontransactional tables
that are visible to other transactions; the transaction can still
modify or lock temporary tables.
MySQL enables extra optimizations for queries on InnoDB tables when
the transaction is known to be read-only. Specifying READ ONLY
ensures these optimizations are applied in cases where the read-only
status cannot be determined automatically. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-performance-ro-txn.htm
l for more information.
If no access mode is specified, the default mode applies. Unless the
default has been changed, it is read/write. It is not permitted to
specify both READ WRITE and READ ONLY in the same statement.
In read-only mode, it remains possible to change tables created with
the TEMPORARY keyword using DML statements. Changes made with DDL
statements are not permitted, just as with permanent tables.
For additional information about transaction access mode, including
ways to change the default mode, see [HELP SET TRANSACTION].
If the read_only system variable is enabled, explicitly starting a
transaction with START TRANSACTION READ WRITE requires the SUPER
privilege.
*Important*:
Many APIs used for writing MySQL client applications (such as JDBC)
provide their own methods for starting transactions that can (and
sometimes should) be used instead of sending a START TRANSACTION
statement from the client. See
https://dev.mysql.com/doc/refman/5.7/en/connectors-apis.html, or the
documentation for your API, for more information.
To disable autocommit mode explicitly, use the following statement:
SET autocommit=0;
After disabling autocommit mode by setting the autocommit variable to
zero, changes to transaction-safe tables (such as those for InnoDB or
NDB) are not made permanent immediately. You must use COMMIT to store
your changes to disk or ROLLBACK to ignore the changes.
autocommit is a session variable and must be set for each session. To
disable autocommit mode for each new connection, see the description of
the autocommit system variable at
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
BEGIN and BEGIN WORK are supported as aliases of START TRANSACTION for
initiating a transaction. START TRANSACTION is standard SQL syntax, is
the recommended way to start an ad-hoc transaction, and permits
modifiers that BEGIN does not.
The BEGIN statement differs from the use of the BEGIN keyword that
starts a BEGIN ... END compound statement. The latter does not begin a
transaction. See [HELP BEGIN END].
*Note*:
Within all stored programs (stored procedures and functions, triggers,
and events), the parser treats BEGIN [WORK] as the beginning of a BEGIN
... END block. Begin a transaction in this context with START
TRANSACTION instead.
The optional WORK keyword is supported for COMMIT and ROLLBACK, as are
the CHAIN and RELEASE clauses. CHAIN and RELEASE can be used for
additional control over transaction completion. The value of the
completion_type system variable determines the default completion
behavior. See
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
The AND CHAIN clause causes a new transaction to begin as soon as the
current one ends, and the new transaction has the same isolation level
as the just-terminated transaction. The new transaction also uses the
same access mode (READ WRITE or READ ONLY) as the just-terminated
transaction. The RELEASE clause causes the server to disconnect the
current client session after terminating the current transaction.
Including the NO keyword suppresses CHAIN or RELEASE completion, which
can be useful if the completion_type system variable is set to cause
chaining or release completion by default.
URL: https://dev.mysql.com/doc/refman/5.7/en/commit.html
https://dev.mysql.com/doc/refman/5.7/en/commit.html p c��� ��Qޠ K J L �E� 8{� 6� infimum supremum3 ܘ@ l "� 6 "COMMIT (Syntax:
START TRANSACTION
[transaction_characteristic [, transaction_characteristic] ...]
transaction_characteristic: {
WITH CONSISTENT SNAPSHOT
| READ WRITE
| READ ONLY
}
BEGIN [WORK]
COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
SET autocommit = {0 | 1}
These statements provide control over use of transactions:
o START TRANSACTION or BEGIN start a new transaction.
o COMMIT commits the current transaction, making its changes permanent.
o ROLLBACK rolls back the current transaction, canceling its changes.
o SET autocommit disables or enables the default autocommit mode for
the current session.
By default, MySQL runs with autocommit mode enabled. This means that,
when not otherwise inside a transaction, each statement is atomic, as
if it were surrounded by START TRANSACTION and COMMIT. You cannot use
ROLLBACK to undo the effect; however, if an error occurs during
statement execution, the statement is rolled back.
To disable autocommit mode implicitly for a single series of
statements, use the START TRANSACTION statement:
START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summary=@A WHERE type=1;
COMMIT;
With START TRANSACTION, autocommit remains disabled until you end the
transaction with COMMIT or ROLLBACK. The autocommit mode then reverts
to its previous state.
START TRANSACTION permits several modifiers that control transaction
characteristics. To specify multiple modifiers, separate them by
commas.
o The WITH CONSISTENT SNAPSHOT modifier starts a consistent read for
storage engines that are capable of it. This applies only to InnoDB.
The effect is the same as issuing a START TRANSACTION followed by a
SELECT from any InnoDB table. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-consistent-read.html.
The WITH CONSISTENT SNAPSHOT modifier does not change the current
transaction isolation level, so it provides a consistent snapshot
only if the current isolation level is one that permits a consistent
read. The only isolation level that permits a consistent read is
REPEATABLE READ. For all other isolation levels, the WITH CONSISTENT
SNAPSHOT clause is ignored. As of MySQL 5.7.2, a warning is generated
when the WITH CONSISTENT SNAPSHOT clause is ignored.
o The READ WRITE and READ ONLY modifiers set the transaction access
mode. They permit or prohibit changes to tables used in the
transaction. The READ ONLY restriction prevents the transaction from
modifying or locking both transactional and nontransactional tables
that are visible to other transactions; the transaction can still
modify or lock temporary tables.
MySQL enables extra optimizations for queries on InnoDB tables when
the transaction is known to be read-only. Specifying READ ONLY
ensures these optimizations are applied in cases where the read-only
status cannot be determined automatically. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-performance-ro-txn.htm
l for more information.
If no access mode is specified, the default mode applies. Unless the
default has been changed, it is read/write. It is not permitted to
specify both READ WRITE and READ ONLY in the same statement.
In read-only mode, it remains possible to change tables created with
the TEMPORARY keyword using DML statements. Changes made with DDL
statements are not permitted, just as with permanent tables.
For additional information about transaction access mode, including
ways to change the default mode, see [HELP SET TRANSACTION].
If the read_only system variable is enabled, explicitly starting a
transaction with START TRANSACTION READ WRITE requires the SUPER
privilege.
*Important*:
Many APIs used for writing MySQL client applications (such as JDBC)
provide their own methods for starting transactions that can (and
sometimes should) be used instead of sending a START TRANSACTION
statement from the client. See
https://dev.mysql.com/doc/refman/5.7/en/connectors-apis.html, or the
documentation for your API, for more information.
To disable autocommit mode explicitly, use the following statement:
SET autocommit=0;
After disabling autocommit mode by setting the autocommit variable to
zero, changes to transaction-safe tables (such as those for InnoDB or
NDB) are not made permanent immediately. You must use COMMIT to store
your changes to disk or ROLLBACK to ignore the changes.
autocommit is a session variable and must be set for each session. To
disable autocommit mode for each new connection, see the description of
the autocommit system variable at
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
BEGIN and BEGIN WORK are supported as aliases of START TRANSACTION for
initiating a transaction. START TRANSACTION is standard SQL syntax, is
the recommended way to start an ad-hoc transaction, and permits
modifiers that BEGIN does not.
The BEGIN statement differs from the use of the BEGIN keyword that
starts a BEGIN ... END compound statement. The latter does not begin a
transaction. See [HELP BEGIN END].
*Note*:
Within all stored programs (stored procedures and functions, triggers,
and events), the parser treats BEGIN [WORK] as the beginning of a BEGIN
... END block. Begin a transaction in this context with START
TRANSACTION instead.
The optional WORK keyword is supported for COMMIT and ROLLBACK, as are
the CHAIN and RELEASE clauses. CHAIN and RELEASE can be used for
additional control over transaction completion. The value of the
completion_type system variable determines the default completion
behavior. See
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
The AND CHAIN clause causes a new transaction to begin as soon as the
current one ends, and the new transaction has the same isolation level
as the just-terminated transaction. The new transaction also uses the
same access mode (READ WRITE or READ ONLY) as the just-terminated
transaction. The RELEASE clause causes the server to disconnect the
current client session after terminating the current transaction.
Including the NO keyword suppresses CHAIN or RELEASE completion, which
can be useful if the completion_type system variable is set to cause
chaining or release completion by default.
URL: https://dev.mysql.com/doc/refman/5.7/en/commit.html
https://dev.mysql.com/doc/refman/5.7/en/commit.html3 ܘ@ l "� 6 /ROLLBACK (Syntax:
START TRANSACTION
[transaction_characteristic [, transaction_characteristic] ...]
transaction_characteristic: {
WITH CONSISTENT SNAPSHOT
| READ WRITE
| READ ONLY
}
BEGIN [WORK]
COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE]
SET autocommit = {0 | 1}
These statements provide control over use of transactions:
o START TRANSACTION or BEGIN start a new transaction.
o COMMIT commits the current transaction, making its changes permanent.
o ROLLBACK rolls back the current transaction, canceling its changes.
o SET autocommit disables or enables the default autocommit mode for
the current session.
By default, MySQL runs with autocommit mode enabled. This means that,
when not otherwise inside a transaction, each statement is atomic, as
if it were surrounded by START TRANSACTION and COMMIT. You cannot use
ROLLBACK to undo the effect; however, if an error occurs during
statement execution, the statement is rolled back.
To disable autocommit mode implicitly for a single series of
statements, use the START TRANSACTION statement:
START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summary=@A WHERE type=1;
COMMIT;
With START TRANSACTION, autocommit remains disabled until you end the
transaction with COMMIT or ROLLBACK. The autocommit mode then reverts
to its previous state.
START TRANSACTION permits several modifiers that control transaction
characteristics. To specify multiple modifiers, separate them by
commas.
o The WITH CONSISTENT SNAPSHOT modifier starts a consistent read for
storage engines that are capable of it. This applies only to InnoDB.
The effect is the same as issuing a START TRANSACTION followed by a
SELECT from any InnoDB table. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-consistent-read.html.
The WITH CONSISTENT SNAPSHOT modifier does not change the current
transaction isolation level, so it provides a consistent snapshot
only if the current isolation level is one that permits a consistent
read. The only isolation level that permits a consistent read is
REPEATABLE READ. For all other isolation levels, the WITH CONSISTENT
SNAPSHOT clause is ignored. As of MySQL 5.7.2, a warning is generated
when the WITH CONSISTENT SNAPSHOT clause is ignored.
o The READ WRITE and READ ONLY modifiers set the transaction access
mode. They permit or prohibit changes to tables used in the
transaction. The READ ONLY restriction prevents the transaction from
modifying or locking both transactional and nontransactional tables
that are visible to other transactions; the transaction can still
modify or lock temporary tables.
MySQL enables extra optimizations for queries on InnoDB tables when
the transaction is known to be read-only. Specifying READ ONLY
ensures these optimizations are applied in cases where the read-only
status cannot be determined automatically. See
https://dev.mysql.com/doc/refman/5.7/en/innodb-performance-ro-txn.htm
l for more information.
If no access mode is specified, the default mode applies. Unless the
default has been changed, it is read/write. It is not permitted to
specify both READ WRITE and READ ONLY in the same statement.
In read-only mode, it remains possible to change tables created with
the TEMPORARY keyword using DML statements. Changes made with DDL
statements are not permitted, just as with permanent tables.
For additional information about transaction access mode, including
ways to change the default mode, see [HELP SET TRANSACTION].
If the read_only system variable is enabled, explicitly starting a
transaction with START TRANSACTION READ WRITE requires the SUPER
privilege.
*Important*:
Many APIs used for writing MySQL client applications (such as JDBC)
provide their own methods for starting transactions that can (and
sometimes should) be used instead of sending a START TRANSACTION
statement from the client. See
https://dev.mysql.com/doc/refman/5.7/en/connectors-apis.html, or the
documentation for your API, for more information.
To disable autocommit mode explicitly, use the following statement:
SET autocommit=0;
After disabling autocommit mode by setting the autocommit variable to
zero, changes to transaction-safe tables (such as those for InnoDB or
NDB) are not made permanent immediately. You must use COMMIT to store
your changes to disk or ROLLBACK to ignore the changes.
autocommit is a session variable and must be set for each session. To
disable autocommit mode for each new connection, see the description of
the autocommit system variable at
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
BEGIN and BEGIN WORK are supported as aliases of START TRANSACTION for
initiating a transaction. START TRANSACTION is standard SQL syntax, is
the recommended way to start an ad-hoc transaction, and permits
modifiers that BEGIN does not.
The BEGIN statement differs from the use of the BEGIN keyword that
starts a BEGIN ... END compound statement. The latter does not begin a
transaction. See [HELP BEGIN END].
*Note*:
Within all stored programs (stored procedures and functions, triggers,
and events), the parser treats BEGIN [WORK] as the beginning of a BEGIN
... END block. Begin a transaction in this context with START
TRANSACTION instead.
The optional WORK keyword is supported for COMMIT and ROLLBACK, as are
the CHAIN and RELEASE clauses. CHAIN and RELEASE can be used for
additional control over transaction completion. The value of the
completion_type system variable determines the default completion
behavior. See
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
The AND CHAIN clause causes a new transaction to begin as soon as the
current one ends, and the new transaction has the same isolation level
as the just-terminated transaction. The new transaction also uses the
same access mode (READ WRITE or READ ONLY) as the just-terminated
transaction. The RELEASE clause causes the server to disconnect the
current client session after terminating the current transaction.
Including the NO keyword suppresses CHAIN or RELEASE completion, which
can be useful if the completion_type system variable is set to cause
chaining or release completion by default.
URL: https://dev.mysql.com/doc/refman/5.7/en/commit.html
https://dev.mysql.com/doc/refman/5.7/en/commit.html6 &�@ � "� 6 <SAVEPOINT (Syntax:
SAVEPOINT identifier
ROLLBACK [WORK] TO [SAVEPOINT] identifier
RELEASE SAVEPOINT identifier
InnoDB supports the SQL statements SAVEPOINT, ROLLBACK TO SAVEPOINT,
RELEASE SAVEPOINT and the optional WORK keyword for ROLLBACK.
URL: https://dev.mysql.com/doc/refman/5.7/en/savepoint.html
https://dev.mysql.com/doc/refman/5.7/en/savepoint.html6 &�@ (� "� 6 IROLLBACK TO SAVEPOINT (Syntax:
SAVEPOINT identifier
ROLLBACK [WORK] TO [SAVEPOINT] identifier
RELEASE SAVEPOINT identifier
InnoDB supports the SQL statements SAVEPOINT, ROLLBACK TO SAVEPOINT,
RELEASE SAVEPOINT and the optional WORK keyword for ROLLBACK.
URL: https://dev.mysql.com/doc/refman/5.7/en/savepoint.html
https://dev.mysql.com/doc/refman/5.7/en/savepoint.html6 &�@ 0ɤ "� 6 VRELEASE SAVEPOINT (Syntax:
SAVEPOINT identifier
ROLLBACK [WORK] TO [SAVEPOINT] identifier
RELEASE SAVEPOINT identifier
InnoDB supports the SQL statements SAVEPOINT, ROLLBACK TO SAVEPOINT,
RELEASE SAVEPOINT and the optional WORK keyword for ROLLBACK.
URL: https://dev.mysql.com/doc/refman/5.7/en/savepoint.html
https://dev.mysql.com/doc/refman/5.7/en/savepoint.html p cQޠ �� � L K O �E� 43�
3� infimum supremum8 ��@ � ! "� 6 cLOCK TABLES (Syntax:
LOCK TABLES
tbl_name [[AS] alias] lock_type
[, tbl_name [[AS] alias] lock_type] ...
lock_type: {
READ [LOCAL]
| [LOW_PRIORITY] WRITE
}
UNLOCK TABLES
MySQL enables client sessions to acquire table locks explicitly for the
purpose of cooperating with other sessions for access to tables, or to
prevent other sessions from modifying tables during periods when a
session requires exclusive access to them. A session can acquire or
release locks only for itself. One session cannot acquire locks for
another session or release locks held by another session.
Locks may be used to emulate transactions or to get more speed when
updating tables. This is explained in more detail in
https://dev.mysql.com/doc/refman/5.7/en/lock-tables.html#lock-tables-re
strictions.
LOCK TABLES explicitly acquires table locks for the current client
session. Table locks can be acquired for base tables or views. You must
have the LOCK TABLES privilege, and the SELECT privilege for each
object to be locked.
For view locking, LOCK TABLES adds all base tables used in the view to
the set of tables to be locked and locks them automatically. As of
MySQL 5.7.32, LOCK TABLES checks that the view definer has the proper
privileges on the tables underlying the view.
If you lock a table explicitly with LOCK TABLES, any tables used in
triggers are also locked implicitly, as described in
https://dev.mysql.com/doc/refman/5.7/en/lock-tables.html#lock-tables-an
d-triggers.
UNLOCK TABLES explicitly releases any table locks held by the current
session. LOCK TABLES implicitly releases any table locks held by the
current session before acquiring new locks.
Another use for UNLOCK TABLES is to release the global read lock
acquired with the FLUSH TABLES WITH READ LOCK statement, which enables
you to lock all tables in all databases. See [HELP FLUSH]. (This is a
very convenient way to get backups if you have a file system such as
Veritas that can take snapshots in time.)
URL: https://dev.mysql.com/doc/refman/5.7/en/lock-tables.html
https://dev.mysql.com/doc/refman/5.7/en/lock-tables.html< g�@ " "� 6 pSET TRANSACTION (Syntax:
SET [GLOBAL | SESSION] TRANSACTION
transaction_characteristic [, transaction_characteristic] ...
transaction_characteristic: {
ISOLATION LEVEL level
| access_mode
}
level: {
REPEATABLE READ
| READ COMMITTED
| READ UNCOMMITTED
| SERIALIZABLE
}
access_mode: {
READ WRITE
| READ ONLY
}
This statement specifies transaction characteristics. It takes a list
of one or more characteristic values separated by commas. Each
characteristic value sets the transaction isolation level or access
mode. The isolation level is used for operations on InnoDB tables. The
access mode specifies whether transactions operate in read/write or
read-only mode.
In addition, SET TRANSACTION can include an optional GLOBAL or SESSION
keyword to indicate the scope of the statement.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html
https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html: ��@ � # "� 6 }XA (Syntax:
XA {START|BEGIN} xid [JOIN|RESUME]
XA END xid [SUSPEND [FOR MIGRATE]]
XA PREPARE xid
XA COMMIT xid [ONE PHASE]
XA ROLLBACK xid
XA RECOVER [CONVERT XID]
For XA START, the JOIN and RESUME clauses are recognized but have no
effect.
For XA END the SUSPEND [FOR MIGRATE] clause is recognized but has no
effect.
Each XA statement begins with the XA keyword, and most of them require
an xid value. An xid is an XA transaction identifier. It indicates
which transaction the statement applies to. xid values are supplied by
the client, or generated by the MySQL server. An xid value has from one
to three parts:
xid: gtrid [, bqual [, formatID ]]
gtrid is a global transaction identifier, bqual is a branch qualifier,
and formatID is a number that identifies the format used by the gtrid
and bqual values. As indicated by the syntax, bqual and formatID are
optional. The default bqual value is '' if not given. The default
formatID value is 1 if not given.
gtrid and bqual must be string literals, each up to 64 bytes (not
characters) long. gtrid and bqual can be specified in several ways. You
can use a quoted string ('ab'), hex string (X'6162', 0x6162), or bit
value (b'nnnn').
formatID is an unsigned integer.
The gtrid and bqual values are interpreted in bytes by the MySQL
server's underlying XA support routines. However, while an SQL
statement containing an XA statement is being parsed, the server works
with some specific character set. To be safe, write gtrid and bqual as
hex strings.
xid values typically are generated by the Transaction Manager. Values
generated by one TM must be different from values generated by other
TMs. A given TM must be able to recognize its own xid values in a list
of values returned by the XA RECOVER statement.
XA START xid starts an XA transaction with the given xid value. Each XA
transaction must have a unique xid value, so the value must not
currently be used by another XA transaction. Uniqueness is assessed
using the gtrid and bqual values. All following XA statements for the
XA transaction must be specified using the same xid value as that given
in the XA START statement. If you use any of those statements but
specify an xid value that does not correspond to some existing XA
transaction, an error occurs.
One or more XA transactions can be part of the same global transaction.
All XA transactions within a given global transaction must use the same
gtrid value in the xid value. For this reason, gtrid values must be
globally unique so that there is no ambiguity about which global
transaction a given XA transaction is part of. The bqual part of the
xid value must be different for each XA transaction within a global
transaction. (The requirement that bqual values be different is a
limitation of the current MySQL XA implementation. It is not part of
the XA specification.)
The XA RECOVER statement returns information for those XA transactions
on the MySQL server that are in the PREPARED state. (See
https://dev.mysql.com/doc/refman/5.7/en/xa-states.html.) The output
includes a row for each such XA transaction on the server, regardless
of which client started it.
XA RECOVER output rows look like this (for an example xid value
consisting of the parts 'abc', 'def', and 7):
mysql> XA RECOVER;
+----------+--------------+--------------+--------+
| formatID | gtrid_length | bqual_length | data |
+----------+--------------+--------------+--------+
| 7 | 3 | 3 | abcdef |
+----------+--------------+--------------+--------+
The output columns have the following meanings:
o formatID is the formatID part of the transaction xid
o gtrid_length is the length in bytes of the gtrid part of the xid
o bqual_length is the length in bytes of the bqual part of the xid
o data is the concatenation of the gtrid and bqual parts of the xid
XID values may contain nonprintable characters. As of MySQL 5.7.5, XA
RECOVER permits an optional CONVERT XID clause so that clients can
request XID values in hexadecimal.
URL: https://dev.mysql.com/doc/refman/5.7/en/xa-statements.html
https://dev.mysql.com/doc/refman/5.7/en/xa-statements.html>V��@ (� $ "� 6 �PURGE BINARY LOGS )Syntax:
PURGE { BINARY | MASTER } LOGS {
TO 'log_name'
| BEFORE datetime_expr
}
The binary log is a set of files that contain information about data
modifications made by the MySQL server. The log consists of a set of
binary log files, plus an index file (see
https://dev.mysql.com/doc/refman/5.7/en/binary-log.html).
The PURGE BINARY LOGS statement deletes all the binary log files listed
in the log index file prior to the specified log file name or date.
BINARY and MASTER are synonyms. Deleted log files also are removed from
the list recorded in the index file, so that the given log file becomes
the first in the list.
PURGE BINARY LOGS requires the BINLOG_ADMIN
(https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_
binlog-admin) privilege. This statement has no effect if the server was
not started with the --log-bin option to enable binary logging.
URL: https://dev.mysql.com/doc/refman/5.7/en/purge-binary-logs.html
PURGE BINARY LOGS TO 'mysql-bin.010';
PURGE BINARY LOGS BEFORE '2019-04-02 22:46:26';
https://dev.mysql.com/doc/refman/5.7/en/purge-binary-logs.html>V��@ 0� % "� 6 �PURGE MASTER LOGS )Syntax:
PURGE { BINARY | MASTER } LOGS {
TO 'log_name'
| BEFORE datetime_expr
}
The binary log is a set of files that contain information about data
modifications made by the MySQL server. The log consists of a set of
binary log files, plus an index file (see
https://dev.mysql.com/doc/refman/5.7/en/binary-log.html).
The PURGE BINARY LOGS statement deletes all the binary log files listed
in the log index file prior to the specified log file name or date.
BINARY and MASTER are synonyms. Deleted log files also are removed from
the list recorded in the index file, so that the given log file becomes
the first in the list.
PURGE BINARY LOGS requires the BINLOG_ADMIN
(https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_
binlog-admin) privilege. This statement has no effect if the server was
not started with the --log-bin option to enable binary logging.
URL: https://dev.mysql.com/doc/refman/5.7/en/purge-binary-logs.html
PURGE BINARY LOGS TO 'mysql-bin.010';
PURGE BINARY LOGS BEFORE '2019-04-02 22:46:26';
https://dev.mysql.com/doc/refman/5.7/en/purge-binary-logs.html9 ��@ 8� & "� 6 �RESET MASTER )Syntax:
RESET MASTER
*Warning*:
Use this statement with caution to ensure you do not lose any wanted
binary log file data and GTID execution history.
RESET MASTER requires the RELOAD privilege.
For a server where binary logging is enabled (log_bin is ON), RESET
MASTER deletes all existing binary log files and resets the binary log
index file, resetting the server to its state before binary logging was
started. A new empty binary log file is created so that binary logging
can be restarted.
For a server where GTIDs are in use (gtid_mode is ON), issuing RESET
MASTER resets the GTID execution history. The value of the gtid_purged
system variable is set to an empty string (''), the global value (but
not the session value) of the gtid_executed system variable is set to
an empty string, and the mysql.gtid_executed table is cleared (see
https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-concepts.html
#replication-gtids-gtid-executed-table). If the GTID-enabled server has
binary logging enabled, RESET MASTER also resets the binary log as
described above. Note that RESET MASTER is the method to reset the GTID
execution history even if the GTID-enabled server is a replica where
binary logging is disabled; RESET SLAVE has no effect on the GTID
execution history. For more information on resetting the GTID execution
history, see
https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-lifecycle.html
#replication-gtids-execution-history.
URL: https://dev.mysql.com/doc/refman/5.7/en/reset-master.html
https://dev.mysql.com/doc/refman/5.7/en/reset-master.html< x�@ @ ' "� 6 �SET SQL_LOG_BIN )Syntax:
SET sql_log_bin = {OFF|ON}
The sql_log_bin variable controls whether logging to the binary log is
enabled for the current session (assuming that the binary log itself is
enabled). The default value is ON. To disable or enable binary logging
for the current session, set the session sql_log_bin variable to OFF or
ON.
Set this variable to OFF for a session to temporarily disable binary
logging while making changes to the source you do not want replicated
to the replica.
Setting the session value of this system variable is a restricted
operation. The session user must have privileges sufficient to set
restricted session variables. See
https://dev.mysql.com/doc/refman/5.7/en/system-variable-privileges.html
.
It is not possible to set the session value of sql_log_bin within a
transaction or subquery.
Setting this variable to OFF prevents GTIDs from being assigned to
transactions in the binary log. If you are using GTIDs for replication,
this means that even when binary logging is later enabled again, the
GTIDs written into the log from this point do not account for any
transactions that occurred in the meantime, so in effect those
transactions are lost.
The global sql_log_bin variable is read only and cannot be modified.
The global scope is deprecated; expect it to be removed in a future
MySQL release.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-sql-log-bin.html
https://dev.mysql.com/doc/refman/5.7/en/set-sql-log-bin.html= �@ H�� ( "� 6 �CHANGE MASTER TO ) M & Z5https://dev.mysql.com/doc/refman/5.7/en/change-master-to.html p � c� � ��? M {�
?� NSyntax:
CHANGE MASTER TO option [, option] ... [ channel_option ]
option: {
MASTER_BIND = 'interface_name'
| MASTER_HOST = 'host_name'
| MASTER_USER = 'user_name'
| MASTER_PASSWORD = 'password'
| MASTER_PORT = port_num
| MASTER_CONNECT_RETRY = interval
| MASTER_RETRY_COUNT = count
| MASTER_DELAY = interval
| MASTER_HEARTBEAT_PERIOD = interval
| MASTER_LOG_FILE = 'source_log_name'
| MASTER_LOG_POS = source_log_pos
| MASTER_AUTO_POSITION = {0|1}
| RELAY_LOG_FILE = 'relay_log_name'
| RELAY_LOG_POS = relay_log_pos
| MASTER_SSL = {0|1}
| MASTER_SSL_CA = 'ca_file_name'
| MASTER_SSL_CAPATH = 'ca_directory_name'
| MASTER_SSL_CERT = 'cert_file_name'
| MASTER_SSL_CRL = 'crl_file_name'
| MASTER_SSL_CRLPATH = 'crl_directory_name'
| MASTER_SSL_KEY = 'key_file_name'
| MASTER_SSL_CIPHER = 'cipher_list'
| MASTER_SSL_VERIFY_SERVER_CERT = {0|1}
| MASTER_TLS_VERSION = 'protocol_list'
| IGNORE_SERVER_IDS = (server_id_list)
}
channel_option:
FOR CHANNEL channel
server_id_list:
[server_id [, server_id] ... ]
CHANGE MASTER TO changes the parameters that the replica uses for
connecting to the replication source server, for reading the source's
binary log, and reading the replica's relay log. It also updates the
contents of the replication metadata repositories (see
https://dev.mysql.com/doc/refman/5.7/en/replica-logs.html). CHANGE
MASTER TO requires the SUPER privilege.
Prior to MySQL 5.7.4, the replication threads must be stopped, using
STOP SLAVE if necessary, before issuing this statement. In MySQL 5.7.4
and later, you can issue CHANGE MASTER TO statements on a running
replica without doing this, depending on the states of the replication
SQL thread and replication I/O thread. The rules governing such use are
provided later in this section.
When using a multithreaded replica (in other words
slave_parallel_workers is greater than 0), stopping the replica can
cause "gaps" in the sequence of transactions that have been executed
from the relay log, regardless of whether the replica was stopped
intentionally or otherwise. When such gaps exist, issuing CHANGE MASTER
TO fails. The solution in this situation is to issue START SLAVE UNTIL
SQL_AFTER_MTS_GAPS which ensures that the gaps are closed.
The optional FOR CHANNEL channel clause enables you to name which
replication channel the statement applies to. Providing a FOR CHANNEL
channel clause applies the CHANGE MASTER TO statement to a specific
replication channel, and is used to add a new channel or modify an
existing channel. For example, to add a new channel called channel2:
CHANGE MASTER TO MASTER_HOST=host1, MASTER_PORT=3002 FOR CHANNEL 'channel2'
If no clause is named and no extra channels exist, the statement
applies to the default channel.
When using multiple replication channels, if a CHANGE MASTER TO
statement does not name a channel using a FOR CHANNEL channel clause,
an error occurs. See
https://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
Options not specified retain their value, except as indicated in the
following discussion. Thus, in most cases, there is no need to specify
options that do not change. For example, if the password to connect to
your replication source server has changed, issue this statement to
tell the replica about the new password:
CHANGE MASTER TO MASTER_PASSWORD='new3cret';
MASTER_HOST, MASTER_USER, MASTER_PASSWORD, and MASTER_PORT provide
information to the replica about how to connect to its replication
source server:
o MASTER_HOST and MASTER_PORT are the host name (or IP address) of the
master host and its TCP/IP port.
*Note*:
Replication cannot use Unix socket files. You must be able to connect
to the replication source server using TCP/IP.
If you specify the MASTER_HOST or MASTER_PORT option, the replica
assumes that the source is different from before (even if the option
value is the same as its current value.) In this case, the old values
for the source's binary log file name and position are considered no
longer applicable, so if you do not specify MASTER_LOG_FILE and
MASTER_LOG_POS in the statement, MASTER_LOG_FILE='' and
MASTER_LOG_POS=4 are silently appended to it.
Setting MASTER_HOST='' (that is, setting its value explicitly to an
empty string) is not the same as not setting MASTER_HOST at all.
Beginning with MySQL 5.5, trying to set MASTER_HOST to an empty
string fails with an error. Previously, setting MASTER_HOST to an
empty string caused START SLAVE subsequently to fail. (Bug #28796)
Values used for MASTER_HOST and other CHANGE MASTER TO options are
checked for linefeed (\n or 0x0A) characters; the presence of such
characters in these values causes the statement to fail with
ER_MASTER_INFO
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference
.html#error_er_master_info). (Bug #11758581, Bug #50801)
o MASTER_USER and MASTER_PASSWORD are the user name and password of the
account to use for connecting to the source. If you specify
MASTER_PASSWORD, MASTER_USER is also required. The password used for
a replication user account in a CHANGE MASTER TO statement is limited
to 32 characters in length; prior to MySQL 5.7.5, if the password was
longer, the statement succeeded, but any excess characters were
silently truncated. In MySQL 5.7.5 and later, trying to use a
password of more than 32 characters causes CHANGE MASTER TO to fail.
(Bug #11752299, Bug #43439)
It is possible to set an empty user name by specifying
MASTER_USER='', but the replication channel cannot be started with an
empty user name. Only set an empty MASTER_USER user name if you need
to clear previously used credentials from the replica's repositories
for security purposes, and do not attempt to use the channel
afterwards.
The text of a running CHANGE MASTER TO statement, including values
for MASTER_USER and MASTER_PASSWORD, can be seen in the output of a
concurrent SHOW PROCESSLIST statement. (The complete text of a START
SLAVE statement is also visible to SHOW PROCESSLIST.)
Setting MASTER_SSL=1 for a replication connection and then setting no
further MASTER_SSL_xxx options corresponds to setting
--ssl-mode=REQUIRED for the client, as described in
https://dev.mysql.com/doc/refman/5.7/en/connection-options.html#encrypt
ed-connection-options. With MASTER_SSL=1, the connection attempt only
succeeds if an encrypted connection can be established. A replication
connection does not fall back to an unencrypted connection, so there is
no setting corresponding to the --ssl-mode=PREFERRED setting for
replication. If MASTER_SSL=0 is set, this corresponds to
--ssl-mode=DISABLED.
*Important*:
To help prevent sophisticated man-in-the-middle attacks, it is
important for the replica to verify the server's identity. You can
specify additional MASTER_SSL_xxx options to correspond to the settings
--ssl-mode=VERIFY_CA and --ssl-mode=VERIFY_IDENTITY, which are a better
choice than the default setting to help prevent this type of attack.
With these settings, the replica checks that the server's certificate
is valid, and checks that the host name the replica is using matches
the identity in the server's certificate. To implement one of these
levels of verification, you must first ensure that the CA certificate
for the server is reliably available to the replica, otherwise
availability issues will result. For this reason, they are not the
default setting.
The MASTER_SSL_xxx options and the MASTER_TLS_VERSION option specify
how the replica uses encryption and ciphers to secure the replication
connection. These options can be changed even on replicas that are
compiled without SSL support. They are saved to the source metadata
repository, but are ignored if the replica does not have SSL support
enabled. The MASTER_SSL_xxx and MASTER_TLS_VERSION options perform the
same functions as the --ssl-xxx and --tls-version client options
described in
https://dev.mysql.com/doc/refman/5.7/en/connection-options.html#encrypt
ed-connection-options. The correspondence between the two sets of
options, and the use of the MASTER_SSL_xxx and MASTER_TLS_VERSION
options to set up a secure connection, is explained in
https://dev.mysql.com/doc/refman/5.7/en/replication-encrypted-connectio
ns.html.
The MASTER_HEARTBEAT_PERIOD, MASTER_CONNECT_RETRY, and
MASTER_RETRY_COUNT options control how the replica recognizes that the
connection to the source has been lost and makes attempts to reconnect.
o The slave_net_timeout system variable specifies the number of seconds
that the replica waits for either more data or a heartbeat signal
from the source, before the replica considers the connection broken,
aborts the read, and tries to reconnect. The default value is 60
seconds (one minute). Prior to MySQL 5.7.7, the default was 3600
seconds (one hour).
o The heartbeat interval, which stops the connection timeout occurring
in the absence of data if the connection is still good, is controlled
by the MASTER_HEARTBEAT_PERIOD option. A heartbeat signal is sent to
the replica after that number of seconds, and the waiting period is
reset whenever the source's binary log is updated with an event.
Heartbeats are therefore sent by the source only if there are no
unsent events in the binary log file for a period longer than this.
The heartbeat interval interval is a decimal value having the range 0
to 4294967 seconds and a resolution in milliseconds; the smallest
nonzero value is 0.001. Setting interval to 0 disables heartbeats
altogether. The heartbeat interval defaults to half the value of the
slave_net_timeout system variable. It is recorded in the source
metadata repository and shown in the
replication_connection_configuration Performance Schema table.
o Prior to MySQL 5.7.4, not including MASTER_HEARTBEAT_PERIOD caused
CHANGE MASTER TO to reset the heartbeat interval to the default (half
the value of the slave_net_timeout system variable), and
Slave_received_heartbeats to 0. The heartbeat interval is now not
reset except by RESET SLAVE. (Bug #18185490)
o Note that a change to the value or default setting of
slave_net_timeout does not automatically change the heartbeat
interval, whether that has been set explicitly or is using a
previously calculated default. A warning is issued if you set
@@GLOBAL.slave_net_timeout to a value less than that of the current
heartbeat interval. If slave_net_timeout is changed, you must also
issue CHANGE MASTER TO to adjust the heartbeat interval to an
appropriate value so that the heartbeat signal occurs before the
connection timeout. If you do not do this, the heartbeat signal has
no effect, and if no data is received from the source, the replica
can make repeated reconnection attempts, creating zombie dump
threads.
o If the replica does need to reconnect, the first retry occurs
immediately after the timeout. MASTER_CONNECT_RETRY specifies the
interval between reconnection attempts, and MASTER_RETRY_COUNT limits
the number of reconnection attempts. If both the default settings are
used, the replica waits 60 seconds between reconnection attempts
(MASTER_CONNECT_RETRY=60), and keeps attempting to reconnect at this
rate for 60 days (MASTER_RETRY_COUNT=86400). A setting of 0 for
MASTER_RETRY_COUNT means that there is no limit on the number of
reconnection attempts, so the replica keeps trying to reconnect
indefinitely. These values are recorded in the source metadata
repository and shown in the replication_connection_configuration
Performance Schema table. MASTER_RETRY_COUNT supersedes the
--master-retry-count server startup option.
MASTER_DELAY specifies how many seconds behind the source the replica
must lag. An event received from the source is not executed until at
least interval seconds later than its execution on the source. The
default is 0. An error occurs if interval is not a nonnegative integer
in the range from 0 to 231−1. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/replication-delayed.html.
From MySQL 5.7, a CHANGE MASTER TO statement employing the MASTER_DELAY
option can be executed on a running replica when the replication SQL
thread is stopped.
MASTER_BIND is for use on replicas having multiple network interfaces,
and determines which of the replica's network interfaces is chosen for
connecting to the source.
The address configured with this option, if any, can be seen in the
Master_Bind column of the output from SHOW SLAVE STATUS. If you are
using a table for the source metadata repository (server started with
master_info_repository=TABLE), the value can also be seen as the
Master_bind column of the mysql.slave_master_info table.
The ability to bind a replica to a specific network interface is also
supported by NDB Cluster.
MASTER_LOG_FILE and MASTER_LOG_POS are the coordinates at which the
replication I/O thread should begin reading from the source the next
time the thread starts. RELAY_LOG_FILE and RELAY_LOG_POS are the
coordinates at which the replication SQL thread should begin reading
from the relay log the next time the thread starts. If you specify any
of these options, you cannot specify MASTER_AUTO_POSITION = 1
(described later in this section). If neither of MASTER_LOG_FILE or
MASTER_LOG_POS is specified, the replica uses the last coordinates of
the replication SQL thread before CHANGE MASTER TO was issued. This
ensures that there is no discontinuity in replication, even if the
replication SQL thread was late compared to the replication I/O thread,
when you merely want to change, say, the password to use.
From MySQL 5.7, a CHANGE MASTER TO statement employing RELAY_LOG_FILE,
RELAY_LOG_POS, or both options can be executed on a running replica
when the replication SQL thread is stopped. Prior to MySQL 5.7.4,
CHANGE MASTER TO deletes all relay log files and starts a new one,
unless you specify RELAY_LOG_FILE or RELAY_LOG_POS. In that case, relay
log files are kept; the relay_log_purge global variable is set silently
to 0. In MySQL 5.7.4 and later, relay logs are preserved if at least
one of the replication SQL thread and the replication I/O thread is
running. If both threads are stopped, all relay log files are deleted
unless at least one of RELAY_LOG_FILE or RELAY_LOG_POS is specified.
For the Group Replication applier channel (group_replication_applier),
which only has an SQL thread and no I/O thread, this is the case if the
SQL thread is stopped, but with that channel you cannot use the
RELAY_LOG_FILE and RELAY_LOG_POS options.
RELAY_LOG_FILE can use either an absolute or relative path, and uses
the same base name as MASTER_LOG_FILE. (Bug #12190)
When MASTER_AUTO_POSITION = 1 is used with CHANGE MASTER TO, the
replica attempts to connect to the source using the auto-positioning
feature of GTID-based replication, rather than a binary log file based
position. From MySQL 5.7, this option can be employed by CHANGE MASTER
TO only if both the replication SQL thread and the replication I/O
thread are stopped. Both the replica and the source must have GTIDs
enabled (GTID_MODE=ON, ON_PERMISSIVE, or OFF_PERMISSIVE on the replica,
and GTID_MODE=ON on the source). MASTER_LOG_FILE, MASTER_LOG_POS,
RELAY_LOG_FILE, and RELAY_LOG_POS cannot be specified together with
MASTER_AUTO_POSITION = 1. If multi-source replication is enabled on the
replica, you need to set the MASTER_AUTO_POSITION = 1 option for each
applicable replication channel.
With MASTER_AUTO_POSITION = 1 set, in the initial connection handshake,
the replica sends a GTID set containing the transactions that it has
already received, committed, or both. The source responds by sending
all transactions recorded in its binary log whose GTID is not included
in the GTID set sent by the replica. This exchange ensures that the
source only sends the transactions with a GTID that the replica has not
already recorded or committed. If the replica receives transactions
from more than one source, as in the case of a diamond topology, the
auto-skip function ensures that the transactions are not applied twice.
For details of how the GTID set sent by the replica is computed, see
https://dev.mysql.com/doc/refman/5.7/en/replicatio��? {�D�9� N {�
k����n-gtids-auto-position
ing.html.
If any of the transactions that should be sent by the source have been
purged from the source's binary log, or added to the set of GTIDs in
the gtid_purged system variable by another method, the source sends the
error ER_MASTER_HAS_PURGED_REQUIRED_GTIDS
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_master_has_purged_required_gtids) to the replica, and
replication does not start. Also, if during the exchange of
transactions it is found that the replica has recorded or committed
transactions with the source's UUID in the GTID, but the source itself
has not committed them, the source sends the error
ER_SLAVE_HAS_MORE_GTIDS_THAN_MASTER
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_slave_has_more_gtids_than_master) to the replica and
replication does not start. For information on how to handle these
situations, see
https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-auto-position
ing.html.
IGNORE_SERVER_IDS takes a comma-separated list of 0 or more server IDs.
Events originating from the corresponding servers are ignored, with the
exception of log rotation and deletion events, which are still recorded
in the relay log.
In circular replication, the originating server normally acts as the
terminator of its own events, so that they are not applied more than
once. Thus, this option is useful in circular replication when one of
the servers in the circle is removed. Suppose that you have a circular
replication setup with 4 servers, having server IDs 1, 2, 3, and 4, and
server 3 fails. When bridging the gap by starting replication from
server 2 to server 4, you can include IGNORE_SERVER_IDS = (3) in the
CHANGE MASTER TO statement that you issue on server 4 to tell it to use
server 2 as its source instead of server 3. Doing so causes it to
ignore and not to propagate any statements that originated with the
server that is no longer in use.
If a CHANGE MASTER TO statement is issued without any IGNORE_SERVER_IDS
option, any existing list is preserved. To clear the list of ignored
servers, it is necessary to use the option with an empty list:
CHANGE MASTER TO IGNORE_SERVER_IDS = ();
Prior to MySQL 5.7.5, RESET SLAVE ALL has no effect on the server ID
list. In MySQL 5.7.5 and later, RESET SLAVE ALL clears
IGNORE_SERVER_IDS. (Bug #18816897)
If IGNORE_SERVER_IDS contains the server's own ID and the server was
started with the --replicate-same-server-id option enabled, an error
results.
The source metadata repository and the output of SHOW SLAVE STATUS
provide the list of servers that are currently ignored. For more
information, see
https://dev.mysql.com/doc/refman/5.7/en/replica-logs-status.html, and
[HELP SHOW SLAVE STATUS].
Invoking CHANGE MASTER TO causes the previous values for MASTER_HOST,
MASTER_PORT, MASTER_LOG_FILE, and MASTER_LOG_POS to be written to the
error log, along with other information about the replica's state prior
to execution.
CHANGE MASTER TO causes an implicit commit of an ongoing transaction.
See https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
In MySQL 5.7.4 and later, the strict requirement to execute STOP SLAVE
prior to issuing any CHANGE MASTER TO statement (and START SLAVE
afterward) is removed. Instead of depending on whether the replica is
stopped, the behavior of CHANGE MASTER TO depends (in MySQL 5.7.4 and
later) on the states of the replication SQL thread and the replication
I/O thread; which of these threads is stopped or running now determines
the options that can or cannot be used with a CHANGE MASTER TO
statement at a given point in time. The rules for making this
determination are listed here:
o If the SQL thread is stopped, you can execute CHANGE MASTER TO using
any combination that is otherwise allowed of RELAY_LOG_FILE,
RELAY_LOG_POS, and MASTER_DELAY options, even if the replication I/O
thread is running. No other options may be used with this statement
when the I/O thread is running.
o If the I/O thread is stopped, you can execute CHANGE MASTER TO using
any of the options for this statement (in any allowed combination)
except RELAY_LOG_FILE, RELAY_LOG_POS, MASTER_DELAY, or
MASTER_AUTO_POSITION = 1 even when the SQL thread is running.
o Both the SQL thread and the I/O thread must be stopped before issuing
a CHANGE MASTER TO statement that employs MASTER_AUTO_POSITION = 1.
You can check the current state of the replication SQL thread and the
replication I/O thread using SHOW SLAVE STATUS. Note that the Group
Replication applier channel (group_replication_applier) has no I/O
thread, only an SQL thread.
For more information, see
https://dev.mysql.com/doc/refman/5.7/en/replication-solutions-switch.html
.
If you are using statement-based replication and temporary tables, it
is possible for a CHANGE MASTER TO statement following a STOP SLAVE
statement to leave behind temporary tables on the replica. From MySQL
5.7, a warning (ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_warn_open_temp_tables_must_be_zero)) is issued whenever
this occurs. You can avoid this in such cases by making sure that the
value of the Slave_open_temp_tables system status variable is equal to
0 prior to executing such a CHANGE MASTER TO statement.
CHANGE MASTER TO is useful for setting up a replica when you have the
snapshot of the replication source server and have recorded the
source's binary log coordinates corresponding to the time of the
snapshot. After loading the snapshot into the replica to synchronize it
with the source, you can run CHANGE MASTER TO
MASTER_LOG_FILE='log_name', MASTER_LOG_POS=log_pos on the replica to
specify the coordinates at which the replica should begin reading the
source's binary log.
The following example changes the replication source server the replica
uses and establishes the source's binary log coordinates from which the
replica begins reading. This is used when you want to set up the
replica to replicate the source:
CHANGE MASTER TO
MASTER_HOST='source2.example.com',
MASTER_USER='replication',
MASTER_PASSWORD='password',
MASTER_PORT=3306,
MASTER_LOG_FILE='source2-bin.001',
MASTER_LOG_POS=4,
MASTER_CONNECT_RETRY=10;
The next example shows an operation that is less frequently employed.
It is used when the replica has relay log files that you want it to
execute again for some reason. To do this, the source need not be
reachable. You need only use CHANGE MASTER TO and start the SQL thread
(START SLAVE SQL_THREAD):
CHANGE MASTER TO
RELAY_LOG_FILE='replica-relay-bin.006',
RELAY_LOG_POS=4025;
URL: https://dev.mysql.com/doc/refman/5.7/en/change-master-to.html
D�9� {�^�� O L Q ! E� .�� -� infimum supremumF /�@ � ) "� 6 �CHANGE REPLICATION FILTER )Syntax:
CHANGE REPLICATION FILTER filter[, filter][, ...]
filter: {
REPLICATE_DO_DB = (db_list)
| REPLICATE_IGNORE_DB = (db_list)
| REPLICATE_DO_TABLE = (tbl_list)
| REPLICATE_IGNORE_TABLE = (tbl_list)
| REPLICATE_WILD_DO_TABLE = (wild_tbl_list)
| REPLICATE_WILD_IGNORE_TABLE = (wild_tbl_list)
| REPLICATE_REWRITE_DB = (db_pair_list)
}
db_list:
db_name[, db_name][, ...]
tbl_list:
db_name.table_name[, db_table_name][, ...]
wild_tbl_list:
'db_pattern.table_pattern'[, 'db_pattern.table_pattern'][, ...]
db_pair_list:
(db_pair)[, (db_pair)][, ...]
db_pair:
from_db, to_db
CHANGE REPLICATION FILTER sets one or more replication filtering rules
on the replica in the same way as starting the replica mysqld with
replication filtering options such as --replicate-do-db or
--replicate-wild-ignore-table. Filters set using this statement differ
from those set using the server options in two key respects:
1. The statement does not require restarting the server to take effect,
only that the replication SQL thread be stopped using STOP SLAVE
SQL_THREAD first (and restarted with START SLAVE SQL_THREAD
afterwards).
2. The effects of the statement are not persistent; any filters set
using CHANGE REPLICATION FILTER are lost following a restart of the
replica mysqld.
CHANGE REPLICATION FILTER requires the SUPER privilege.
Replication filters cannot be set on a MySQL server instance that is
configured for Group Replication, because filtering transactions on
some servers would make the group unable to reach agreement on a
consistent state.
The following list shows the CHANGE REPLICATION FILTER options and how
they relate to --replicate-* server options:
o REPLICATE_DO_DB: Include updates based on database name. Equivalent
to --replicate-do-db.
o REPLICATE_IGNORE_DB: Exclude updates based on database name.
Equivalent to --replicate-ignore-db.
o REPLICATE_DO_TABLE: Include updates based on table name. Equivalent
to --replicate-do-table.
o REPLICATE_IGNORE_TABLE: Exclude updates based on table name.
Equivalent to --replicate-ignore-table.
o REPLICATE_WILD_DO_TABLE: Include updates based on wildcard pattern
matching table name. Equivalent to --replicate-wild-do-table.
o REPLICATE_WILD_IGNORE_TABLE: Exclude updates based on wildcard
pattern matching table name. Equivalent to
--replicate-wild-ignore-table.
o REPLICATE_REWRITE_DB: Perform updates on replica after substituting
new name on replica for specified database on source. Equivalent to
--replicate-rewrite-db.
The precise effects of REPLICATE_DO_DB and REPLICATE_IGNORE_DB filters
are dependent on whether statement-based or row-based replication is in
effect. See
https://dev.mysql.com/doc/refman/5.7/en/replication-rules.html, for
more information.
Multiple replication filtering rules can be created in a single CHANGE
REPLICATION FILTER statement by separating the rules with commas, as
shown here:
CHANGE REPLICATION FILTER
REPLICATE_DO_DB = (d1), REPLICATE_IGNORE_DB = (d2);
Issuing the statement just shown is equivalent to starting the replica
mysqld with the options --replicate-do-db=d1 --replicate-ignore-db=d2.
If the same filtering rule is specified multiple times, only the last
such rule is actually used. For example, the two statements shown here
have exactly the same effect, because the first REPLICATE_DO_DB rule in
the first statement is ignored:
CHANGE REPLICATION FILTER
REPLICATE_DO_DB = (db1, db2), REPLICATE_DO_DB = (db3, db4);
CHANGE REPLICATION FILTER
REPLICATE_DO_DB = (db3,db4);
*Caution*:
This behavior differs from that of the --replicate-* filter options
where specifying the same option multiple times causes the creation of
multiple filter rules.
Names of tables and database not containing any special characters need
not be quoted. Values used with REPLICATION_WILD_TABLE and
REPLICATION_WILD_IGNORE_TABLE are string expressions, possibly
containing (special) wildcard characters, and so must be quoted. This
is shown in the following example statements:
CHANGE REPLICATION FILTER
REPLICATE_WILD_DO_TABLE = ('db1.old%');
CHANGE REPLICATION FILTER
REPLICATE_WILD_IGNORE_TABLE = ('db1.new%', 'db2.new%');
Values used with REPLICATE_REWRITE_DB represent pairs of database
names; each such value must be enclosed in parentheses. The following
statement rewrites statements occurring on database db1 on the source
to database db2 on the replica:
CHANGE REPLICATION FILTER REPLICATE_REWRITE_DB = ((db1, db2));
The statement just shown contains two sets of parentheses, one
enclosing the pair of database names, and the other enclosing the
entire list. This is perhaps more easily seen in the following example,
which creates two rewrite-db rules, one rewriting database dbA to dbB,
and one rewriting database dbC to dbD:
CHANGE REPLICATION FILTER
REPLICATE_REWRITE_DB = ((dbA, dbB), (dbC, dbD));
This statement leaves any existing replication filtering rules
unchanged; to unset all filters of a given type, set the filter's value
to an explicitly empty list, as shown in this example, which removes
all existing REPLICATE_DO_DB and REPLICATE_IGNORE_DB rules:
CHANGE REPLICATION FILTER
REPLICATE_DO_DB = (), REPLICATE_IGNORE_DB = ();
Setting a filter to empty in this way removes all existing rules, does
not create any new ones, and does not restore any rules set at mysqld
startup using --replicate-* options on the command line or in the
configuration file.
Values employed with REPLICATE_WILD_DO_TABLE and
REPLICATE_WILD_IGNORE_TABLE must be in the format db_name.tbl_name.
Prior to MySQL 5.7.5, this was not strictly enforced, although using
nonconforming values with these options could lead to erroneous results
(Bug #18095449).
For more information, see
https://dev.mysql.com/doc/refman/5.7/en/replication-rules.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/change-replication-filter.html
https://dev.mysql.com/doc/refman/5.7/en/change-replication-filter.html8 �@ � * "� 6 �RESET SLAVE )Syntax:
RESET SLAVE [ALL] [channel_option]
channel_option:
FOR CHANNEL channel
RESET SLAVE makes the replica forget its replication position in the
source's binary log. This statement is meant to be used for a clean
start: It clears the replication metadata repositories, deletes all the
relay log files, and starts a new relay log file. It also resets to 0
the replication delay specified with the MASTER_DELAY option to CHANGE
MASTER TO.
*Note*:
All relay log files are deleted, even if they have not been completely
executed by the replication SQL thread. (This is a condition likely to
exist on a replica if you have issued a STOP SLAVE statement or if the
replica is highly loaded.)
For a server where GTIDs are in use (gtid_mode is ON), issuing RESET
SLAVE has no effect on the GTID execution history. The statement does
not change the values of gtid_executed or gtid_purged, or the
mysql.gtid_executed table. If you need to reset the GTID execution
history, use RESET MASTER, even if the GTID-enabled server is a replica
where binary logging is disabled.
RESET SLAVE requires the RELOAD privilege.
To use RESET SLAVE, the replication threads must be stopped, so on a
running replica use STOP SLAVE before issuing RESET SLAVE. To use RESET
SLAVE on a Group Replication group member, the member status must be
OFFLINE, meaning that the plugin is loaded but the member does not
currently belong to any group. A group member can be taken offline by
using a STOP GROUP REPLICATION statement.
The optional FOR CHANNEL channel clause enables you to name which
replication channel the statement applies to. Providing a FOR CHANNEL
channel clause applies the RESET SLAVE statement to a specific
replication channel. Combining a FOR CHANNEL channel clause with the
ALL option deletes the specified channel. If no channel is named and no
extra channels exist, the statement applies to the default channel.
Issuing a RESET SLAVE ALL statement without a FOR CHANNEL channel
clause when multiple replication channels exist deletes all replication
channels and recreates only the default channel. See
https://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
RESET SLAVE does not change any replication connection parameters such
as the source's host name and port, or the replication user account
name and its password.
o From MySQL 5.7.24, when master_info_repository=TABLE is set on the
server, replication connection parameters are preserved in the
crash-safe InnoDB table mysql.slave_master_info as part of the RESET
SLAVE operation. They are also retained in memory. In the event of an
unexpected server exit or deliberate restart after issuing RESET
SLAVE but before issuing START SLAVE, the replication connection
parameters are retrieved from the table and reused for the new
connection.
o When master_info_repository=FILE is set on the server (which is the
default in MySQL 5.7), replication connection parameters are only
retained in memory. If the replica mysqld is restarted immediately
after issuing RESET SLAVE due to an unexpected server exit or
deliberate restart, the connection parameters are lost. In that case,
you must issue a CHANGE MASTER TO statement after the server start to
respecify the connection parameters before issuing START SLAVE.
If you want to reset the connection parameters intentionally, you need
to use RESET SLAVE ALL, which clears the connection parameters. In that
case, you must issue a CHANGE MASTER TO statement after the server
start to specify the new connection parameters.
RESET SLAVE causes an implicit commit of an ongoing transaction. See
https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
If the replication SQL thread was in the middle of replicating
temporary tables when it was stopped, and RESET SLAVE is issued, these
replicated temporary tables are deleted on the replica.
Prior to MySQL 5.7.5, RESET SLAVE also had the effect of resetting both
the heartbeat period (Slave_heartbeat_period) and
SSL_VERIFY_SERVER_CERT. This issue is fixed in MySQL 5.7.5 and later.
(Bug #18777899, Bug #18778485)
Prior to MySQL 5.7.5, RESET SLAVE ALL did not clear the
IGNORE_SERVER_IDS list set by CHANGE MASTER TO. In MySQL 5.7.5 and
later, the statement clears the list. (Bug #18816897)
*Note*:
When used on an NDB Cluster replica SQL node, RESET SLAVE clears the
mysql.ndb_apply_status table. You should keep in mind when using this
statement that ndb_apply_status uses the NDB storage engine and so is
shared by all SQL nodes attached to the replica cluster.
You can override this behavior by issuing SET GLOBAL
@@ndb_clear_apply_status=OFF prior to executing RESET SLAVE, which
keeps the replica from purging the ndb_apply_status table in such
cases.
URL: https://dev.mysql.com/doc/refman/5.7/en/reset-slave.html
https://dev.mysql.com/doc/refman/5.7/en/reset-slave.htmlN p�@ + "� 6 �SET GLOBAL SQL_SLAVE_SKIP_COUNTER )Syntax:
SET GLOBAL sql_slave_skip_counter = N
This statement skips the next N events from the master. This is useful
for recovering from replication stops caused by a statement.
This statement is valid only when the slave threads are not running.
Otherwise, it produces an error.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-global-sql-slave-skip-counter.html
https://dev.mysql.com/doc/refman/5.7/en/set-global-sql-slave-skip-counter.html8 �@ (�} , "� 6 �START SLAVE ) P & )�https://dev.mysql.com/doc/refman/5.7/en/start-slave.html p c^�� ! ��w� P �
)����Syntax:
START SLAVE [thread_types] [until_option] [connection_options] [channel_option]
thread_types:
[thread_type [, thread_type] ... ]
thread_type:
IO_THREAD | SQL_THREAD
until_option:
UNTIL { {SQL_BEFORE_GTIDS | SQL_AFTER_GTIDS} = gtid_set
| MASTER_LOG_FILE = 'log_name', MASTER_LOG_POS = log_pos
| RELAY_LOG_FILE = 'log_name', RELAY_LOG_POS = log_pos
| SQL_AFTER_MTS_GAPS }
connection_options:
[USER='user_name'] [PASSWORD='user_pass'] [DEFAULT_AUTH='plugin_name'] [PLUGIN_DIR='plugin_dir']
channel_option:
FOR CHANNEL channel
gtid_set:
uuid_set [, uuid_set] ...
| ''
uuid_set:
uuid:interval[:interval]...
uuid:
hhhhhhhh-hhhh-hhhh-hhhh-hhhhhhhhhhhh
h:
[0-9,A-F]
interval:
n[-n]
(n >= 1)
START SLAVE starts the replication threads, either together or
separately. The statement requires the SUPER privilege. START SLAVE
causes an implicit commit of an ongoing transaction (see
https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html).
For the thread type options, you can specify IO_THREAD, SQL_THREAD,
both of these, or neither of them. Only the threads that are started
are affected by the statement.
o START SLAVE with no thread type options starts all of the replication
threads, and so does START SLAVE with both of the thread type
options.
o IO_THREAD starts the replication receiver thread, which reads events
from the source server and stores them in the relay log.
o SQL_THREAD starts the replication applier thread, which reads events
from the relay log and executes them. A multithreaded replica (with
slave_parallel_workers > 0) applies transactions using a coordinator
thread and multiple applier threads, and SQL_THREAD starts all of
these.
*Important*:
START SLAVE sends an acknowledgment to the user after all the
replication threads have started. However, the replication receiver
thread might not yet have connected to the source successfully, or an
applier thread might stop when applying an event right after starting.
START SLAVE does not continue to monitor the threads after they are
started, so it does not warn you if they subsequently stop or cannot
connect. You must check the replica's error log for error messages
generated by the replication threads, or check that they are running
satisfactorily with SHOW SLAVE STATUS. A successful START SLAVE
statement causes SHOW SLAVE STATUS to show Slave_SQL_Running=Yes, but
it might or might not show Slave_IO_Running=Yes, because
Slave_IO_Running=Yes is only shown if the receiver thread is both
running and connected. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/replication-administration-stat
us.html.
The optional FOR CHANNEL channel clause enables you to name which
replication channel the statement applies to. Providing a FOR CHANNEL
channel clause applies the START SLAVE statement to a specific
replication channel. If no clause is named and no extra channels exist,
the statement applies to the default channel. If a START SLAVE
statement does not have a channel defined when using multiple channels,
this statement starts the specified threads for all channels. See
https://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
The replication channels for Group Replication
(group_replication_applier and group_replication_recovery) are managed
automatically by the server instance. The only Group Replication
channel that you can interact with is the group_replication_applier
channel. This channel only has an applier thread and has no receiver
thread, so it can be started by using the SQL_THREAD option without the
IO_THREAD option. START SLAVE cannot be used at all with the
group_replication_recovery channel.
START SLAVE supports pluggable user-password authentication (see
https://dev.mysql.com/doc/refman/5.7/en/pluggable-authentication.html)
with the USER, PASSWORD, DEFAULT_AUTH and PLUGIN_DIR options, as
described in the following list. When you use these options, you must
start the receiver thread (IO_THREAD option) or all the replication
threads; you cannot start the replication applier thread (SQL_THREAD
option) alone.
o USER
The user name for the account. You must set this if PASSWORD is used.
The option cannot be set to an empty or null string.
o PASSWORD
The password for the named user account.
o DEFAULT_AUTH
The name of the authentication plugin. The default is MySQL native
authentication.
o PLUGIN_DIR
The location of the authentication plugin.
*Important*:
The password that you set using START SLAVE is masked when it is
written to MySQL Server's logs, Performance Schema tables, and SHOW
PROCESSLIST statements. However, it is sent in plain text over the
connection to the replica server instance. To protect the password in
transit, use SSL/TLS encryption, an SSH tunnel, or another method of
protecting the connection from unauthorized viewing, for the connection
between the replica server instance and the client that you use to
issue START SLAVE.
The UNTIL clause makes the replica start replication, then process
transactions up to the point that you specify in the UNTIL clause, then
stop again. The UNTIL clause can be used to make a replica proceed
until just before the point where you want to skip a transaction that
is unwanted, and then skip the transaction as described in
https://dev.mysql.com/doc/refman/5.7/en/replication-administration-skip
.html. To identify a transaction, you can use mysqlbinlog with the
source's binary log or the replica's relay log, or use a SHOW BINLOG
EVENTS statement.
You can also use the UNTIL clause for debugging replication by
processing transactions one at a time or in sections. If you are using
the UNTIL clause to do this, start the replica with the
--skip-slave-start option to prevent the SQL thread from running when
the replica server starts. Remove the option after the procedure is
complete, so that it is not forgotten in the event of an unexpected
server restart.
The SHOW SLAVE STATUS statement includes output fields that display the
current values of the UNTIL condition. The UNTIL condition lasts for as
long as the affected threads are still running, and is removed when
they stop.
The UNTIL clause operates on the replication applier thread (SQL_THREAD
option). You can use the SQL_THREAD option or let the replica default
to starting both threads. If you use the IO_THREAD option alone, the
UNTIL clause is ignored because the applier thread is not started.
The point that you specify in the UNTIL clause can be any one (and only
one) of the following options:
o SOURCE_LOG_FILE and SOURCE_LOG_POS
These options make the replication applier process transactions up to
a position in its relay log, identified by the file name and file
position of the corresponding point in the binary log on the source
server. The applier thread finds the nearest transaction boundary at
or after the specified position, finishes applying the transaction,
and stops there.
o RELAY_LOG_FILE and RELAY_LOG_POS
These options make the replication applier process transactions up to
a position in the replica's relay log, identified by the relay log
file name and a position in that file. The applier thread finds the
nearest transaction boundary at or after the specified position,
finishes applying the transaction, and stops there.
o SQL_BEFORE_GTIDS
This option makes the replication applier start processing
transactions and stop when it encounters any transaction that is in
the specified GTID set. The encountered transaction from the GTID set
is not applied, and nor are any of the other transactions in the GTID
set. The option takes a GTID set containing one or more global
transaction identifiers as an argument (see
https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-concepts.ht
ml#replication-gtids-concepts-gtid-sets). Transactions in a GTID set
do not necessarily appear in the replication stream in the order of
their GTIDs, so the transaction before which the applier stops is not
necessarily the earliest.
o SQL_AFTER_GTIDS
This option makes the replication applier start processing
transactions and stop when it has processed all of the transactions
in a specified GTID set. The option takes a GTID set containing one
or more global transaction identifiers as an argument (see
https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-concepts.ht
ml#replication-gtids-concepts-gtid-sets).
With SQL_AFTER_GTIDS, the replication threads stop after they have
processed all transactions in the GTID set. Transactions are
processed in the order received, so it is possible that these include
transactions which are not part of the GTID set, but which are
received (and processed) before all transactions in the set have been
committed. For example, executing START SLAVE UNTIL SQL_AFTER_GTIDS =
3E11FA47-71CA-11E1-9E33-C80AA9429562:11-56 causes the replica to
obtain (and process) all transactions from the source until all of
the transactions having the sequence numbers 11 through 56 have been
processed, and then to stop without processing any additional
transactions after that point has been reached.
o SQL_AFTER_MTS_GAPS
For a multithreaded replica only (with slave_parallel_workers > 0),
this option makes the replica process transactions up to the point
where there are no more gaps in the sequence of transactions executed
from the relay log. When using a multithreaded replica, there is a
chance of gaps occurring in the following situations:
o The coordinator thread is stopped.
o An error occurs in the applier threads.
o mysqld shuts down unexpectedly.
When a replication channel has gaps, the replica's database is in a
state that might never have existed on the source. The replica tracks
the gaps internally and disallows CHANGE MASTER TO statements that
would remove the gap information if they executed.
Issuing START SLAVE on a multithreaded replica with gaps in the
sequence of transactions executed from the relay log generates a
warning. To correct this situation, the solution is to use START
SLAVE UNTIL SQL_AFTER_MTS_GAPS. See
https://dev.mysql.com/doc/refman/5.7/en/replication-features-transact
ion-inconsistencies.html for more information.
If you need to change a failed multithreaded replica to
single-threaded mode, you can issue the following series of
statements, in the order shown:
START SLAVE UNTIL SQL_AFTER_MTS_GAPS;
SET @@GLOBAL.slave_parallel_workers = 0;
START SLAVE SQL_THREAD;
URL: https://dev.mysql.com/doc/refman/5.7/en/start-slave.html
��w� ���ͨ Q O R !awE� 5H�
0. infimum supremum7 z�@ - "� 6 �STOP SLAVE )Syntax:
STOP SLAVE [thread_types] [channel_option]
thread_types:
[thread_type [, thread_type] ... ]
thread_type: IO_THREAD | SQL_THREAD
channel_option:
FOR CHANNEL channel
Stops the replication threads. STOP SLAVE requires the SUPER privilege.
Recommended best practice is to execute STOP SLAVE on the replica
before stopping the replica server (see
https://dev.mysql.com/doc/refman/5.7/en/server-shutdown.html, for more
information).
When using the row-based logging format: You should execute STOP SLAVE
or STOP SLAVE SQL_THREAD on the replica prior to shutting down the
replica server if you are replicating any tables that use a
nontransactional storage engine (see the Note later in this section).
Like START SLAVE, this statement may be used with the IO_THREAD and
SQL_THREAD options to name the thread or threads to be stopped. Note
that the Group Replication applier channel (group_replication_applier)
has no replication I/O thread, only a replication SQL thread. Using the
SQL_THREAD option therefore stops this channel completely.
STOP SLAVE causes an implicit commit of an ongoing transaction. See
https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
gtid_next must be set to AUTOMATIC before issuing this statement.
You can control how long STOP SLAVE waits before timing out by setting
the rpl_stop_slave_timeout system variable. This can be used to avoid
deadlocks between STOP SLAVE and other SQL statements using different
client connections to the replica. When the timeout value is reached,
the issuing client returns an error message and stops waiting, but the
STOP SLAVE instruction remains in effect. Once the replication threads
are no longer busy, the STOP SLAVE statement is executed and the
replica stops.
Some CHANGE MASTER TO statements are allowed while the replica is
running, depending on the states of the replication SQL thread and the
replication I/O thread. However, using STOP SLAVE prior to executing
CHANGE MASTER TO in such cases is still supported. See [HELP CHANGE
MASTER TO], and
https://dev.mysql.com/doc/refman/5.7/en/replication-solutions-switch.html
, for more information.
The optional FOR CHANNEL channel clause enables you to name which
replication channel the statement applies to. Providing a FOR CHANNEL
channel clause applies the STOP SLAVE statement to a specific
replication channel. If no channel is named and no extra channels
exist, the statement applies to the default channel. If a STOP SLAVE
statement does not name a channel when using multiple channels, this
statement stops the specified threads for all channels. This statement
cannot be used with the group_replication_recovery channel. See
https://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
When using statement-based replication: changing the source while it
has open temporary tables is potentially unsafe. This is one of the
reasons why statement-based replication of temporary tables is not
recommended. You can find out whether there are any temporary tables on
the replica by checking the value of Slave_open_temp_tables; when using
statement-based replication, this value should be 0 before executing
CHANGE MASTER TO. If there are any temporary tables open on the
replica, issuing a CHANGE MASTER TO statement after issuing a STOP
SLAVE causes an ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference.html
#error_er_warn_open_temp_tables_must_be_zero) warning.
When using a multithreaded replica (slave_parallel_workers is a nonzero
value), any gaps in the sequence of transactions executed from the
relay log are closed as part of stopping the worker threads. If the
replica is stopped unexpectedly (for example due to an error in a
worker thread, or another thread issuing KILL) while a STOP SLAVE
statement is executing, the sequence of executed transactions from the
relay log may become inconsistent. See
https://dev.mysql.com/doc/refman/5.7/en/replication-features-transactio
n-inconsistencies.html, for more information.
If the current replication event group has modified one or more
nontransactional tables, STOP SLAVE waits for up to 60 seconds for the
event group to complete, unless you issue a KILL QUERY or KILL
CONNECTION statement for the replication SQL thread. If the event group
remains incomplete after the timeout, an error message is logged.
URL: https://dev.mysql.com/doc/refman/5.7/en/stop-slave.html
https://dev.mysql.com/doc/refman/5.7/en/stop-slave.html4 w�@
. "� 6 PREPARE *Syntax:
PREPARE stmt_name FROM preparable_stmt
The PREPARE statement prepares a SQL statement and assigns it a name,
stmt_name, by which to refer to the statement later. The prepared
statement is executed with EXECUTE and released with DEALLOCATE
PREPARE. For examples, see
https://dev.mysql.com/doc/refman/5.7/en/sql-prepared-statements.html.
Statement names are not case-sensitive. preparable_stmt is either a
string literal or a user variable that contains the text of the SQL
statement. The text must represent a single statement, not multiple
statements. Within the statement, ? characters can be used as parameter
markers to indicate where data values are to be bound to the query
later when you execute it. The ? characters should not be enclosed
within quotation marks, even if you intend to bind them to string
values. Parameter markers can be used only where data values should
appear, not for SQL keywords, identifiers, and so forth.
If a prepared statement with the given name already exists, it is
deallocated implicitly before the new statement is prepared. This means
that if the new statement contains an error and cannot be prepared, an
error is returned and no statement with the given name exists.
The scope of a prepared statement is the session within which it is
created, which as several implications:
o A prepared statement created in one session is not available to other
sessions.
o When a session ends, whether normally or abnormally, its prepared
statements no longer exist. If auto-reconnect is enabled, the client
is not notified that the connection was lost. For this reason,
clients may wish to disable auto-reconnect. See Automatic
Reconnection Control
(https://dev.mysql.com/doc/c-api/5.7/en/c-api-auto-reconnect.html).
o A prepared statement created within a stored program continues to
exist after the program finishes executing and can be executed
outside the program later.
o A statement prepared in stored program context cannot refer to stored
procedure or function parameters or local variables because they go
out of scope when the program ends and would be unavailable were the
statement to be executed later outside the program. As a workaround,
refer instead to user-defined variables, which also have session
scope; see
https://dev.mysql.com/doc/refman/5.7/en/user-variables.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/prepare.html
https://dev.mysql.com/doc/refman/5.7/en/prepare.html4 �@ � / "� 6 EXECUTE STATEMENT *Syntax:
EXECUTE stmt_name
[USING @var_name [, @var_name] ...]
After preparing a statement with PREPARE, you execute it with an
EXECUTE statement that refers to the prepared statement name. If the
prepared statement contains any parameter markers, you must supply a
USING clause that lists user variables containing the values to be
bound to the parameters. Parameter values can be supplied only by user
variables, and the USING clause must name exactly as many variables as
the number of parameter markers in the statement.
You can execute a given prepared statement multiple times, passing
different variables to it or setting the variables to different values
before each execution.
URL: https://dev.mysql.com/doc/refman/5.7/en/execute.html
https://dev.mysql.com/doc/refman/5.7/en/execute.html? 8�@ (� 0 "� 6 &DEALLOCATE PREPARE *Syntax:
{DEALLOCATE | DROP} PREPARE stmt_name
To deallocate a prepared statement produced with PREPARE, use a
DEALLOCATE PREPARE statement that refers to the prepared statement
name. Attempting to execute a prepared statement after deallocating it
results in an error. If too many prepared statements are created and
not deallocated by either the DEALLOCATE PREPARE statement or the end
of the session, you might encounter the upper limit enforced by the
max_prepared_stmt_count system variable.
URL: https://dev.mysql.com/doc/refman/5.7/en/deallocate-prepare.html
https://dev.mysql.com/doc/refman/5.7/en/deallocate-prepare.html? 8�@ 0� 1 "� 6 3DROP PREPARE *Syntax:
{DEALLOCATE | DROP} PREPARE stmt_name
To deallocate a prepared statement produced with PREPARE, use a
DEALLOCATE PREPARE statement that refers to the prepared statement
name. Attempting to execute a prepared statement after deallocating it
results in an error. If too many prepared statements are created and
not deallocated by either the DEALLOCATE PREPARE statement or the end
of the session, you might encounter the upper limit enforced by the
max_prepared_stmt_count system variable.
URL: https://dev.mysql.com/doc/refman/5.7/en/deallocate-prepare.html
https://dev.mysql.com/doc/refman/5.7/en/deallocate-prepare.html6 8�@ 8� 2 "� 6 @BEGIN END +Syntax:
[begin_label:] BEGIN
[statement_list]
END [end_label]
BEGIN ... END syntax is used for writing compound statements, which can
appear within stored programs (stored procedures and functions,
triggers, and events). A compound statement can contain multiple
statements, enclosed by the BEGIN and END keywords. statement_list
represents a list of one or more statements, each terminated by a
semicolon (;) statement delimiter. The statement_list itself is
optional, so the empty compound statement (BEGIN END) is legal.
BEGIN ... END blocks can be nested.
Use of multiple statements requires that a client is able to send
statement strings containing the ; statement delimiter. In the mysql
command-line client, this is handled with the delimiter command.
Changing the ; end-of-statement delimiter (for example, to //) permit ;
to be used in a program body. For an example, see
https://dev.mysql.com/doc/refman/5.7/en/stored-programs-defining.html.
A BEGIN ... END block can be labeled. See [HELP labels].
URL: https://dev.mysql.com/doc/refman/5.7/en/begin-end.html
https://dev.mysql.com/doc/refman/5.7/en/begin-end.html= �@ @� 3 "� 6 MLABELS +Syntax:
[begin_label:] BEGIN
[statement_list]
END [end_label]
[begin_label:] LOOP
statement_list
END LOOP [end_label]
[begin_label:] REPEAT
statement_list
UNTIL search_condition
END REPEAT [end_label]
[begin_label:] WHILE search_condition DO
statement_list
END WHILE [end_label]
Labels are permitted for BEGIN ... END blocks and for the LOOP, REPEAT,
and WHILE statements. Label use for those statements follows these
rules:
o begin_label must be followed by a colon.
o begin_label can be given without end_label. If end_label is present,
it must be the same as begin_label.
o end_label cannot be given without begin_label.
o Labels at the same nesting level must be distinct.
o Labels can be up to 16 characters long.
To refer to a label within the labeled construct, use an ITERATE or
LEAVE statement. The following example uses those statements to
continue iterating or terminate the loop:
CREATE PROCEDURE doiterate(p1 INT)
BEGIN
label1: LOOP
SET p1 = p1 + 1;
IF p1 < 10 THEN ITERATE label1; END IF;
LEAVE label1;
END LOOP label1;
END;
The scope of a block label does not include the code for handlers
declared within the block. For details, see [HELP DECLARE HANDLER].
URL: https://dev.mysql.com/doc/refman/5.7/en/statement-labels.html
https://dev.mysql.com/doc/refman/5.7/en/statement-labels.htmlC ��@ H�B 4 "� 6 ZDECLARE VARIABLE +Syntax:
DECLARE var_name [, var_name] ... type [DEFAULT value]
This statement declares local variables within stored programs. To
provide a default value for a variable, include a DEFAULT clause. The
value can be specified as an expression; it need not be a constant. If
the DEFAULT clause is missing, the initial value is NULL.
Local variables are treated like stored routine parameters with respect
to data type and overflow checking. See [HELP CREATE PROCEDURE].
Variable declarations must appear before cursor or handler
declarations.
Local variable names are not case-sensitive. Permissible characters and
quoting rules are the same as for other identifiers, as described in
https://dev.mysql.com/doc/refman/5.7/en/identifiers.html.
The scope of a local variable is the BEGIN ... END block within which
it is declared. The variable can be referred to in blocks nested within
the declaring block, except those blocks that declare a variable with
the same name.
For examples of variable declarations, see
https://dev.mysql.com/doc/refman/5.7/en/local-variable-scope.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/declare-local-variable.html
https://dev.mysql.com/doc/refman/5.7/en/declare-local-variable.html p c��ͨ !aw&��� R Q S !� E� 0�� *&
infimum supremum1 ��@ 5 "� 6 gCASE STATEMENT +Syntax:
CASE case_value
WHEN when_value THEN statement_list
[WHEN when_value THEN statement_list] ...
[ELSE statement_list]
END CASE
Or:
CASE
WHEN search_condition THEN statement_list
[WHEN search_condition THEN statement_list] ...
[ELSE statement_list]
END CASE
The CASE statement for stored programs implements a complex conditional
construct.
*Note*:
There is also a CASE operator, which differs from the CASE statement
described here. See
https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.html.
The CASE statement cannot have an ELSE NULL clause, and it is
terminated with END CASE instead of END.
For the first syntax, case_value is an expression. This value is
compared to the when_value expression in each WHEN clause until one of
them is equal. When an equal when_value is found, the corresponding
THEN clause statement_list executes. If no when_value is equal, the
ELSE clause statement_list executes, if there is one.
This syntax cannot be used to test for equality with NULL because NULL
= NULL is false. See
https://dev.mysql.com/doc/refman/5.7/en/working-with-null.html.
For the second syntax, each WHEN clause search_condition expression is
evaluated until one is true, at which point its corresponding THEN
clause statement_list executes. If no search_condition is equal, the
ELSE clause statement_list executes, if there is one.
If no when_value or search_condition matches the value tested and the
CASE statement contains no ELSE clause, a Case not found for CASE
statement error results.
Each statement_list consists of one or more SQL statements; an empty
statement_list is not permitted.
To handle situations where no value is matched by any WHEN clause, use
an ELSE containing an empty BEGIN ... END block, as shown in this
example. (The indentation used here in the ELSE clause is for purposes
of clarity only, and is not otherwise significant.)
DELIMITER |
CREATE PROCEDURE p()
BEGIN
DECLARE v INT DEFAULT 1;
CASE v
WHEN 2 THEN SELECT v;
WHEN 3 THEN SELECT 0;
ELSE
BEGIN
END;
END CASE;
END;
|
URL: https://dev.mysql.com/doc/refman/5.7/en/case.html
https://dev.mysql.com/doc/refman/5.7/en/case.html/ 2�@ � 6 "� 6 tIF STATEMENT +Syntax:
IF search_condition THEN statement_list
[ELSEIF search_condition THEN statement_list] ...
[ELSE statement_list]
END IF
The IF statement for stored programs implements a basic conditional
construct.
*Note*:
There is also an IF() function, which differs from the IF statement
described here. See
https://dev.mysql.com/doc/refman/5.7/en/flow-control-functions.html.
The IF statement can have THEN, ELSE, and ELSEIF clauses, and it is
terminated with END IF.
If a given search_condition evaluates to true, the corresponding THEN
or ELSEIF clause statement_list executes. If no search_condition
matches, the ELSE clause statement_list executes.
Each statement_list consists of one or more SQL statements; an empty
statement_list is not permitted.
URL: https://dev.mysql.com/doc/refman/5.7/en/if.html
https://dev.mysql.com/doc/refman/5.7/en/if.html4 ��@ M 7 "� 6 �ITERATE +Syntax:
ITERATE label
ITERATE can appear only within LOOP, REPEAT, and WHILE statements.
ITERATE means "start the loop again."
URL: https://dev.mysql.com/doc/refman/5.7/en/iterate.html
https://dev.mysql.com/doc/refman/5.7/en/iterate.html2 F�@ (� 8 "� 6 �LEAVE +Syntax:
LEAVE label
This statement is used to exit the flow control construct that has the
given label. If the label is for the outermost stored program block,
LEAVE exits the program.
LEAVE can be used within BEGIN ... END or loop constructs (LOOP,
REPEAT, WHILE).
URL: https://dev.mysql.com/doc/refman/5.7/en/leave.html
https://dev.mysql.com/doc/refman/5.7/en/leave.html1����@ 0 9 "� 6 �LOOP +Syntax:
[begin_label:] LOOP
statement_list
END LOOP [end_label]
LOOP implements a simple loop construct, enabling repeated execution of
the statement list, which consists of one or more statements, each
terminated by a semicolon (;) statement delimiter. The statements
within the loop are repeated until the loop is terminated. Usually,
this is accomplished with a LEAVE statement. Within a stored function,
RETURN can also be used, which exits the function entirely.
Neglecting to include a loop-termination statement results in an
infinite loop.
A LOOP statement can be labeled. For the rules regarding label use, see
[HELP labels].
URL: https://dev.mysql.com/doc/refman/5.7/en/loop.html
CREATE PROCEDURE doiterate(p1 INT)
BEGIN
label1: LOOP
SET p1 = p1 + 1;
IF p1 < 10 THEN
ITERATE label1;
END IF;
LEAVE label1;
END LOOP label1;
SET @x = p1;
END;
https://dev.mysql.com/doc/refman/5.7/en/loop.html3����@ 8 : "� 6 �REPEAT LOOP +Syntax:
[begin_label:] REPEAT
statement_list
UNTIL search_condition
END REPEAT [end_label]
The statement list within a REPEAT statement is repeated until the
search_condition expression is true. Thus, a REPEAT always enters the
loop at least once. statement_list consists of one or more statements,
each terminated by a semicolon (;) statement delimiter.
A REPEAT statement can be labeled. For the rules regarding label use,
see [HELP labels].
URL: https://dev.mysql.com/doc/refman/5.7/en/repeat.html
mysql> delimiter //
mysql> CREATE PROCEDURE dorepeat(p1 INT)
BEGIN
SET @x = 0;
REPEAT
SET @x = @x + 1;
UNTIL @x > p1 END REPEAT;
END
//
Query OK, 0 rows affected (0.00 sec)
mysql> CALL dorepeat(1000)//
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @x//
+------+
| @x |
+------+
| 1001 |
+------+
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/repeat.html3 ف@ @i ; "� 6 �RETURN +Syntax:
RETURN expr
The RETURN statement terminates execution of a stored function and
returns the value expr to the function caller. There must be at least
one RETURN statement in a stored function. There may be more than one
if the function has multiple exit points.
This statement is not used in stored procedures, triggers, or events.
The LEAVE statement can be used to exit a stored program of those
types.
URL: https://dev.mysql.com/doc/refman/5.7/en/return.html
https://dev.mysql.com/doc/refman/5.7/en/return.html2Ɂ@ H� < "� 6 �WHILE +Syntax:
[begin_label:] WHILE search_condition DO
statement_list
END WHILE [end_label]
The statement list within a WHILE statement is repeated as long as the
search_condition expression is true. statement_list consists of one or
more SQL statements, each terminated by a semicolon (;) statement
delimiter.
A WHILE statement can be labeled. For the rules regarding label use,
see [HELP labels].
URL: https://dev.mysql.com/doc/refman/5.7/en/while.html
CREATE PROCEDURE dowhile()
BEGIN
DECLARE v1 INT DEFAULT 5;
WHILE v1 > 0 DO
...
SET v1 = v1 - 1;
END WHILE;
END;
https://dev.mysql.com/doc/refman/5.7/en/while.html2 k�@ P� = "� 6 �CLOSE +Syntax:
CLOSE cursor_name
This statement closes a previously opened cursor. For an example, see
https://dev.mysql.com/doc/refman/5.7/en/cursors.html.
An error occurs if the cursor is not open.
If not closed explicitly, a cursor is closed at the end of the BEGIN
... END block in which it was declared.
URL: https://dev.mysql.com/doc/refman/5.7/en/close.html
https://dev.mysql.com/doc/refman/5.7/en/close.html; ��@ XW > "� 6 �DECLARE CURSOR +Syntax:
DECLARE cursor_name CURSOR FOR select_statement
This statement declares a cursor and associates it with a SELECT
statement that retrieves the rows to be traversed by the cursor. To
fetch the rows later, use a FETCH statement. The number of columns
retrieved by the SELECT statement must match the number of output
variables specified in the FETCH statement.
The SELECT statement cannot have an INTO clause.
Cursor declarations must appear before handler declarations and after
variable and condition declarations.
A stored program may contain multiple cursor declarations, but each
cursor declared in a given block must have a unique name. For an
example, see https://dev.mysql.com/doc/refman/5.7/en/cursors.html.
For information available through SHOW statements, it is possible in
many cases to obtain equivalent information by using a cursor with an
INFORMATION_SCHEMA table.
URL: https://dev.mysql.com/doc/refman/5.7/en/declare-cursor.html
https://dev.mysql.com/doc/refman/5.7/en/declare-cursor.html2 �@ `� ? "� 6 �FETCH +Syntax:
FETCH [[NEXT] FROM] cursor_name INTO var_name [, var_name] ...
This statement fetches the next row for the SELECT statement associated
with the specified cursor (which must be open), and advances the cursor
pointer. If a row exists, the fetched columns are stored in the named
variables. The number of columns retrieved by the SELECT statement must
match the number of output variables specified in the FETCH statement.
If no more rows are available, a No Data condition occurs with SQLSTATE
value '02000'. To detect this condition, you can set up a handler for
it (or for a NOT FOUND condition). For an example, see
https://dev.mysql.com/doc/refman/5.7/en/cursors.html.
Be aware that another operation, such as a SELECT or another FETCH, may
also cause the handler to execute by raising the same condition. If it
is necessary to distinguish which operation raised the condition, place
the operation within its own BEGIN ... END block so that it can be
associated with its own handler.
URL: https://dev.mysql.com/doc/refman/5.7/en/fetch.html
https://dev.mysql.com/doc/refman/5.7/en/fetch.html1 Ѐ@ h^ @ "� 6 �OPEN +Syntax:
OPEN cursor_name
This statement opens a previously declared cursor. For an example, see
https://dev.mysql.com/doc/refman/5.7/en/cursors.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/open.html
https://dev.mysql.com/doc/refman/5.7/en/open.html> �@ p�J A "� 6 DECLARE CONDITION +Syntax:
DECLARE condition_name CONDITION FOR condition_value
condition_value: {
mysql_error_code
| SQLSTATE [VALUE] sqlstate_value
}
The DECLARE ... CONDITION statement declares a named error condition,
associating a name with a condition that needs specific handling. The
name can be referred to in a subsequent DECLARE ... HANDLER statement
(see [HELP DECLARE HANDLER]).
Condition declarations must appear before cursor or handler
declarations.
The condition_value for DECLARE ... CONDITION indicates the specific
condition or class of conditions to associate with the condition name.
It can take the following forms:
o mysql_error_code: An integer literal indicating a MySQL error code.
Do not use MySQL error code 0 because that indicates success rather
than an error condition. For a list of MySQL error codes, see Server
Error Message Reference
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference
.html).
o SQLSTATE [VALUE] sqlstate_value: A 5-character string literal
indicating an SQLSTATE value.
Do not use SQLSTATE values that begin with '00' because those
indicate success rather than an error condition. For a list of
SQLSTATE values, see Server Error Message Reference
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference
.html).
Condition names referred to in SIGNAL or use RESIGNAL statements must
be associated with SQLSTATE values, not MySQL error codes.
URL: https://dev.mysql.com/doc/refman/5.7/en/declare-condition.html
https://dev.mysql.com/doc/refman/5.7/en/declare-condition.html p�� c&��� !� >�ц S R U !�gE� 6�� 2� infimum supremum<g�|�@ | B "� 6 DECLARE HANDLER +Syntax:
DECLARE handler_action HANDLER
FOR condition_value [, condition_value] ...
statement
handler_action: {
CONTINUE
| EXIT
| UNDO
}
condition_value: {
mysql_error_code
| SQLSTATE [VALUE] sqlstate_value
| condition_name
| SQLWARNING
| NOT FOUND
| SQLEXCEPTION
}
The DECLARE ... HANDLER statement specifies a handler that deals with
one or more conditions. If one of these conditions occurs, the
specified statement executes. statement can be a simple statement such
as SET var_name = value, or a compound statement written using BEGIN
and END (see [HELP BEGIN END]).
Handler declarations must appear after variable or condition
declarations.
The handler_action value indicates what action the handler takes after
execution of the handler statement:
o CONTINUE: Execution of the current program continues.
o EXIT: Execution terminates for the BEGIN ... END compound statement
in which the handler is declared. This is true even if the condition
occurs in an inner block.
o UNDO: Not supported.
The condition_value for DECLARE ... HANDLER indicates the specific
condition or class of conditions that activates the handler. It can
take the following forms:
o mysql_error_code: An integer literal indicating a MySQL error code,
such as 1051 to specify "unknown table":
DECLARE CONTINUE HANDLER FOR 1051
BEGIN
-- body of handler
END;
Do not use MySQL error code 0 because that indicates success rather
than an error condition. For a list of MySQL error codes, see Server
Error Message Reference
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference
.html).
o SQLSTATE [VALUE] sqlstate_value: A 5-character string literal
indicating an SQLSTATE value, such as '42S01' to specify "unknown
table":
DECLARE CONTINUE HANDLER FOR SQLSTATE '42S02'
BEGIN
-- body of handler
END;
Do not use SQLSTATE values that begin with '00' because those
indicate success rather than an error condition. For a list of
SQLSTATE values, see Server Error Message Reference
(https://dev.mysql.com/doc/mysql-errors/5.7/en/server-error-reference
.html).
o condition_name: A condition name previously specified with DECLARE
... CONDITION. A condition name can be associated with a MySQL error
code or SQLSTATE value. See [HELP DECLARE CONDITION].
o SQLWARNING: Shorthand for the class of SQLSTATE values that begin
with '01'.
DECLARE CONTINUE HANDLER FOR SQLWARNING
BEGIN
-- body of handler
END;
o NOT FOUND: Shorthand for the class of SQLSTATE values that begin with
'02'. This is relevant within the context of cursors and is used to
control what happens when a cursor reaches the end of a data set. If
no more rows are available, a No Data condition occurs with SQLSTATE
value '02000'. To detect this condition, you can set up a handler for
it or for a NOT FOUND condition.
DECLARE CONTINUE HANDLER FOR NOT FOUND
BEGIN
-- body of handler
END;
For another example, see
https://dev.mysql.com/doc/refman/5.7/en/cursors.html. The NOT FOUND
condition also occurs for SELECT ... INTO var_list statements that
retrieve no rows.
o SQLEXCEPTION: Shorthand for the class of SQLSTATE values that do not
begin with '00', '01', or '02'.
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
BEGIN
-- body of handler
END;
For information about how the server chooses handlers when a condition
occurs, see https://dev.mysql.com/doc/refman/5.7/en/handler-scope.html.
If a condition occurs for which no handler has been declared, the
action taken depends on the condition class:
o For SQLEXCEPTION conditions, the stored program terminates at the
statement that raised the condition, as if there were an EXIT
handler. If the program was called by another stored program, the
calling program handles the condition using the handler selection
rules applied to its own handlers.
o For SQLWARNING conditions, the program continues executing, as if
there were a CONTINUE handler.
o For NOT FOUND conditions, if the condition was raised normally, the
action is CONTINUE. If it was raised by SIGNAL or RESIGNAL, the
action is EXIT.
URL: https://dev.mysql.com/doc/refman/5.7/en/declare-handler.html
mysql> CREATE TABLE test.t (s1 INT, PRIMARY KEY (s1));
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter //
mysql> CREATE PROCEDURE handlerdemo ()
BEGIN
DECLARE CONTINUE HANDLER FOR SQLSTATE '23000' SET @x2 = 1;
SET @x = 1;
INSERT INTO test.t VALUES (1);
SET @x = 2;
INSERT INTO test.t VALUES (1);
SET @x = 3;
END;
//
Query OK, 0 rows affected (0.00 sec)
mysql> CALL handlerdemo()//
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @x//
+------+
| @x |
+------+
| 3 |
+------+
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/declare-handler.html< �@ � C "� 6 GET DIAGNOSTICS + T & thttps://dev.mysql.com/doc/refman/5.7/en/get-diagnostics.html5 t�@ D "� 6 *RESIGNAL +Syntax:
RESIGNAL [condition_value]
[SET signal_information_item
[, signal_information_item] ...]
condition_value: {
SQLSTATE [VALUE] sqlstate_value
| condition_name
}
signal_information_item:
condition_information_item_name = simple_value_specification
condition_information_item_name: {
CLASS_ORIGIN
| SUBCLASS_ORIGIN
| MESSAGE_TEXT
| MYSQL_ERRNO
| CONSTRAINT_CATALOG
| CONSTRAINT_SCHEMA
| CONSTRAINT_NAME
| CATALOG_NAME
| SCHEMA_NAME
| TABLE_NAME
| COLUMN_NAME
| CURSOR_NAME
}
condition_name, simple_value_specification:
(see following discussion)
RESIGNAL passes on the error condition information that is available
during execution of a condition handler within a compound statement
inside a stored procedure or function, trigger, or event. RESIGNAL may
change some or all information before passing it on. RESIGNAL is
related to SIGNAL, but instead of originating a condition as SIGNAL
does, RESIGNAL relays existing condition information, possibly after
modifying it.
RESIGNAL makes it possible to both handle an error and return the error
information. Otherwise, by executing an SQL statement within the
handler, information that caused the handler's activation is destroyed.
RESIGNAL also can make some procedures shorter if a given handler can
handle part of a situation, then pass the condition "up the line" to
another handler.
No privileges are required to execute the RESIGNAL statement.
All forms of RESIGNAL require that the current context be a condition
handler. Otherwise, RESIGNAL is illegal and a RESIGNAL when handler not
active error occurs.
To retrieve information from the diagnostics area, use the GET
DIAGNOSTICS statement (see [HELP GET DIAGNOSTICS]). For information
about the diagnostics area, see
https://dev.mysql.com/doc/refman/5.7/en/diagnostics-area.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/resignal.html
https://dev.mysql.com/doc/refman/5.7/en/resignal.html3�>�@ (� E "� 6 7SIGNAL +Syntax:
SIGNAL condition_value
[SET signal_information_item
[, signal_information_item] ...]
condition_value: {
SQLSTATE [VALUE] sqlstate_value
| condition_name
}
signal_information_item:
condition_information_item_name = simple_value_specification
condition_information_item_name: {
CLASS_ORIGIN
| SUBCLASS_ORIGIN
| MESSAGE_TEXT
| MYSQL_ERRNO
| CONSTRAINT_CATALOG
| CONSTRAINT_SCHEMA
| CONSTRAINT_NAME
| CATALOG_NAME
| SCHEMA_NAME
| TABLE_NAME
| COLUMN_NAME
| CURSOR_NAME
}
condition_name, simple_value_specification:
(see following discussion)
SIGNAL is the way to "return" an error. SIGNAL provides error
information to a handler, to an outer portion of the application, or to
the client. Also, it provides control over the error's characteristics
(error number, SQLSTATE value, message). Without SIGNAL, it is
necessary to resort to workarounds such as deliberately referring to a
nonexistent table to cause a routine to return an error.
No privileges are required to execute the SIGNAL statement.
To retrieve information from the diagnostics area, use the GET
DIAGNOSTICS statement (see [HELP GET DIAGNOSTICS]). For information
about the diagnostics area, see
https://dev.mysql.com/doc/refman/5.7/en/diagnostics-area.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/signal.html
CREATE PROCEDURE p (pval INT)
BEGIN
DECLARE specialty CONDITION FOR SQLSTATE '45000';
IF pval = 0 THEN
SIGNAL SQLSTATE '01000';
ELSEIF pval = 1 THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'An error occurred';
ELSEIF pval = 2 THEN
SIGNAL specialty
SET MESSAGE_TEXT = 'An error occurred';
ELSE
SIGNAL SQLSTATE '01000'
SET MESSAGE_TEXT = 'A warning occurred', MYSQL_ERRNO = 1000;
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'An error occurred', MYSQL_ERRNO = 1001;
END IF;
END;
https://dev.mysql.com/doc/refman/5.7/en/signal.html7 a�@ 0� F "� 6 DALTER USER ,Syntax:
ALTER USER [IF EXISTS]
user [auth_option] [, user [auth_option]] ...
[REQUIRE {NONE | tls_option [[AND] tls_option] ...}]
[WITH resource_option [resource_option] ...]
[password_option | lock_option] ...
ALTER USER [IF EXISTS]
USER() IDENTIFIED BY 'auth_string'
user:
(see )
auth_option: {
IDENTIFIED BY 'auth_string'
| IDENTIFIED WITH auth_plugin
| IDENTIFIED WITH auth_plugin BY 'auth_string'
| IDENTIFIED WITH auth_plugin AS 'auth_string'
}
tls_option: {
SSL
| X509
| CIPHER 'cipher'
| ISSUER 'issuer'
| SUBJECT 'subject'
}
resource_option: {
MAX_QUERIES_PER_HOUR count
| MAX_UPDATES_PER_HOUR count
| MAX_CONNECTIONS_PER_HOUR count
| MAX_USER_CONNECTIONS count
}
password_option: {
PASSWORD EXPIRE
| PASSWORD EXPIRE DEFAULT
| PASSWORD EXPIRE NEVER
| PASSWORD EXPIRE INTERVAL N DAY
}
lock_option: {
ACCOUNT LOCK
| ACCOUNT UNLOCK
}
The ALTER USER statement modifies MySQL accounts. It enables
authentication, SSL/TLS, resource-limit, and password-management
properties to be modified for existing accounts. It can also be used to
lock and unlock accounts.
To use ALTER USER, you must have the global CREATE USER privilege or
the UPDATE privilege for the mysql system database. When the read_only
system variable is enabled, ALTER USER additionally requires the SUPER
privilege.
By default, an error occurs if you try to modify a user that does not
exist. If the IF EXISTS clause is given, the statement produces a
warning for each named user that does not exist, rather than an error.
URL: https://dev.mysql.com/doc/refman/5.7/en/alter-user.html
https://dev.mysql.com/doc/refman/5.7/en/alter-user.html8 d�@ 8� G "� 6 QCREATE USER ,Syntax:
CREATE USER [IF NOT EXISTS]
user [auth_option] [, user [auth_option]] ...
[REQUIRE {NONE | tls_option [[AND] tls_option] ...}]
[WITH resource_option [resource_option] ...]
[password_option | lock_option] ...
user:
(see )
auth_option: {
IDENTIFIED BY 'auth_string'
| IDENTIFIED WITH auth_plugin
| IDENTIFIED WITH auth_plugin BY 'auth_string'
| IDENTIFIED WITH auth_plugin AS 'auth_string'
| IDENTIFIED BY PASSWORD 'auth_string'
}
tls_option: {
SSL
| X509
| CIPHER 'cipher'
| ISSUER 'issuer'
| SUBJECT 'subject'
}
resource_option: {
MAX_QUERIES_PER_HOUR count
| MAX_UPDATES_PER_HOUR count
| MAX_CONNECTIONS_PER_HOUR count
| MAX_USER_CONNECTIONS count
}
password_option: {
PASSWORD EXPIRE
| PASSWORD EXPIRE DEFAULT
| PASSWORD EXPIRE NEVER
| PASSWORD EXPIRE INTERVAL N DAY
}
lock_option: {
ACCOUNT LOCK
| ACCOUNT UNLOCK
}
The CREATE USER statement creates new MySQL accounts. It enables
authentication, SSL/TLS, resource-limit, and password-management
properties to be established for new accounts, and controls whether
accounts are initially locked or unlocked.
To use CREATE USER, you must have the global CREATE USER privilege, or
the INSERT privilege for the mysql system database. When the read_only
system variable is enabled, CREATE USER additionally requires the SUPER
privilege.
An error occurs if you try to create an account that already exists. If
the IF NOT EXISTS clause is given, the statement produces a warning for
each named account that already exists, rather than an error.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-user.html
https://dev.mysql.com/doc/refman/5.7/en/create-user.html6 ��@ @�� H "� 6 ^DROP USER ,Syntax:
DROP USER [IF EXISTS] user [, user] ...
The DROP USER statement removes one or more MySQL accounts and their
privileges. It removes privilege rows for the account from all grant
tables.
To use DROP USER, you must have the global CREATE USER privilege, or
the DELETE privilege for the mysql system database. When the read_only
system variable is enabled, DROP USER additionally requires the SUPER
privilege.
An error occurs if you try to drop an account that does not exist. If
the IF EXISTS clause is given, the statement produces a warning for
each named user that does not exist, rather than an error.
Each account name uses the format described in
https://dev.mysql.com/doc/refman/5.7/en/account-names.html. For
example:
DROP USER 'jeffrey'@'localhost';
The host name part of the account name, if omitted, defaults to '%'.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-user.html
https://dev.mysql.com/doc/refman/5.7/en/drop-user.html p c>�ц !�gNv�� T !�}
t����Syntax:
GET [CURRENT | STACKED] DIAGNOSTICS {
statement_information_item
[, statement_information_item] ...
| CONDITION condition_number
condition_information_item
[, condition_information_item] ...
}
statement_information_item:
target = statement_information_item_name
condition_information_item:
target = condition_information_item_name
statement_information_item_name: {
NUMBER
| ROW_COUNT
}
condition_information_item_name: {
CLASS_ORIGIN
| SUBCLASS_ORIGIN
| RETURNED_SQLSTATE
| MESSAGE_TEXT
| MYSQL_ERRNO
| CONSTRAINT_CATALOG
| CONSTRAINT_SCHEMA
| CONSTRAINT_NAME
| CATALOG_NAME
| SCHEMA_NAME
| TABLE_NAME
| COLUMN_NAME
| CURSOR_NAME
}
condition_number, target:
(see following discussion)
SQL statements produce diagnostic information that populates the
diagnostics area. The GET DIAGNOSTICS statement enables applications to
inspect this information. (You can also use SHOW WARNINGS or SHOW
ERRORS to see conditions or errors.)
No special privileges are required to execute GET DIAGNOSTICS.
The keyword CURRENT means to retrieve information from the current
diagnostics area. The keyword STACKED means to retrieve information
from the second diagnostics area, which is available only if the
current context is a condition handler. If neither keyword is given,
the default is to use the current diagnostics area.
The GET DIAGNOSTICS statement is typically used in a handler within a
stored program. It is a MySQL extension that GET [CURRENT] DIAGNOSTICS
is permitted outside handler context to check the execution of any SQL
statement. For example, if you invoke the mysql client program, you can
enter these statements at the prompt:
mysql> DROP TABLE test.no_such_table;
ERROR 1051 (42S02): Unknown table 'test.no_such_table'
mysql> GET DIAGNOSTICS CONDITION 1
@p1 = RETURNED_SQLSTATE, @p2 = MESSAGE_TEXT;
mysql> SELECT @p1, @p2;
+-------+------------------------------------+
| @p1 | @p2 |
+-------+------------------------------------+
| 42S02 | Unknown table 'test.no_such_table' |
+-------+------------------------------------+
This extension applies only to the current diagnostics area. It does
not apply to the second diagnostics area because GET STACKED
DIAGNOSTICS is permitted only if the current context is a condition
handler. If that is not the case, a GET STACKED DIAGNOSTICS when
handler not active error occurs.
For a description of the diagnostics area, see
https://dev.mysql.com/doc/refman/5.7/en/diagnostics-area.html. Briefly,
it contains two kinds of information:
o Statement information, such as the number of conditions that occurred
or the affected-rows count.
o Condition information, such as the error code and message. If a
statement raises multiple conditions, this part of the diagnostics
area has a condition area for each one. If a statement raises no
conditions, this part of the diagnostics area is empty.
For a statement that produces three conditions, the diagnostics area
contains statement and condition information like this:
Statement information:
row count
... other statement information items ...
Condition area list:
Condition area 1:
error code for condition 1
error message for condition 1
... other condition information items ...
Condition area 2:
error code for condition 2:
error message for condition 2
... other condition information items ...
Condition area 3:
error code for condition 3
error message for condition 3
... other condition information items ...
GET DIAGNOSTICS can obtain either statement or condition information,
but not both in the same statement:
o To obtain statement information, retrieve the desired statement items
into target variables. This instance of GET DIAGNOSTICS assigns the
number of available conditions and the rows-affected count to the
user variables @p1 and @p2:
GET DIAGNOSTICS @p1 = NUMBER, @p2 = ROW_COUNT;
o To obtain condition information, specify the condition number and
retrieve the desired condition items into target variables. This
instance of GET DIAGNOSTICS assigns the SQLSTATE value and error
message to the user variables @p3 and @p4:
GET DIAGNOSTICS CONDITION 1
@p3 = RETURNED_SQLSTATE, @p4 = MESSAGE_TEXT;
The retrieval list specifies one or more target = item_name
assignments, separated by commas. Each assignment names a target
variable and either a statement_information_item_name or
condition_information_item_name designator, depending on whether the
statement retrieves statement or condition information.
Valid target designators for storing item information can be stored
procedure or function parameters, stored program local variables
declared with DECLARE, or user-defined variables.
Valid condition_number designators can be stored procedure or function
parameters, stored program local variables declared with DECLARE,
user-defined variables, system variables, or literals. A character
literal may include a _charset introducer. A warning occurs if the
condition number is not in the range from 1 to the number of condition
areas that have information. In this case, the warning is added to the
diagnostics area without clearing it.
When a condition occurs, MySQL does not populate all condition items
recognized by GET DIAGNOSTICS. For example:
mysql> GET DIAGNOSTICS CONDITION 1
@p5 = SCHEMA_NAME, @p6 = TABLE_NAME;
mysql> SELECT @p5, @p6;
+------+------+
| @p5 | @p6 |
+------+------+
| | |
+------+------+
In standard SQL, if there are multiple conditions, the first condition
relates to the SQLSTATE value returned for the previous SQL statement.
In MySQL, this is not guaranteed. To get the main error, you cannot do
this:
GET DIAGNOSTICS CONDITION 1 @errno = MYSQL_ERRNO;
Instead, retrieve the condition count first, then use it to specify
which condition number to inspect:
GET DIAGNOSTICS @cno = NUMBER;
GET DIAGNOSTICS CONDITION @cno @errno = MYSQL_ERRNO;
For information about permissible statement and condition information
items, and which ones are populated when a condition occurs, see
https://dev.mysql.com/doc/refman/5.7/en/diagnostics-area.html#diagnosti
cs-area-information-items.
Here is an example that uses GET DIAGNOSTICS and an exception handler
in stored procedure context to assess the outcome of an insert
operation. If the insert was successful, the procedure uses GET
DIAGNOSTICS to get the rows-affected count. This shows that you can use
GET DIAGNOSTICS multiple times to retrieve information about a
statement as long as the current diagnostics area has not been cleared.
CREATE PROCEDURE do_insert(value INT)
BEGIN
-- Declare variables to hold diagnostics area information
DECLARE code CHAR(5) DEFAULT '00000';
DECLARE msg TEXT;
DECLARE nrows INT;
DECLARE result TEXT;
-- Declare exception handler for failed insert
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
BEGIN
GET DIAGNOSTICS CONDITION 1
code = RETURNED_SQLSTATE, msg = MESSAGE_TEXT;
END;
-- Perform the insert
INSERT INTO t1 (int_col) VALUES(value);
-- Check whether the insert was successful
IF code = '00000' THEN
GET DIAGNOSTICS nrows = ROW_COUNT;
SET result = CONCAT('insert succeeded, row count = ',nrows);
ELSE
SET result = CONCAT('insert failed, error = ',code,', message = ',msg);
END IF;
-- Say what happened
SELECT result;
END;
Suppose that t1.int_col is an integer column that is declared as NOT
NULL. The procedure produces these results when invoked to insert
non-NULL and NULL values, respectively:
mysql> CALL do_insert(1);
+---------------------------------+
| result |
+---------------------------------+
| insert succeeded, row count = 1 |
+---------------------------------+
mysql> CALL do_insert(NULL);
+-------------------------------------------------------------------------+
| result |
+-------------------------------------------------------------------------+
| insert failed, error = 23000, message = Column 'int_col' cannot be null |
+-------------------------------------------------------------------------+
URL: https://dev.mysql.com/doc/refman/5.7/en/get-diagnostics.html
Nv�� !�}�� U S V ",�E� :5� 6� infimum supremum2 3�@
� I "� 6 kGRANT ,Syntax:
GRANT
priv_type [(column_list)]
[, priv_type [(column_list)]] ...
ON [object_type] priv_level
TO user [auth_option] [, user [auth_option]] ...
[REQUIRE {NONE | tls_option [[AND] tls_option] ...}]
[WITH {GRANT OPTION | resource_option} ...]
GRANT PROXY ON user
TO user [, user] ...
[WITH GRANT OPTION]
object_type: {
TABLE
| FUNCTION
| PROCEDURE
}
priv_level: {
*
| *.*
| db_name.*
| db_name.tbl_name
| tbl_name
| db_name.routine_name
}
user:
(see https://dev.mysql.com/doc/refman/5.7/en/account-names.html)
auth_option: {
IDENTIFIED BY 'auth_string'
| IDENTIFIED WITH auth_plugin
| IDENTIFIED WITH auth_plugin BY 'auth_string'
| IDENTIFIED WITH auth_plugin AS 'auth_string'
| IDENTIFIED BY PASSWORD 'auth_string'
}
tls_option: {
SSL
| X509
| CIPHER 'cipher'
| ISSUER 'issuer'
| SUBJECT 'subject'
}
resource_option: {
| MAX_QUERIES_PER_HOUR count
| MAX_UPDATES_PER_HOUR count
| MAX_CONNECTIONS_PER_HOUR count
| MAX_USER_CONNECTIONS count
}
The GRANT statement grants privileges to MySQL user accounts.
To grant a privilege with GRANT, you must have the GRANT OPTION
privilege, and you must have the privileges that you are granting.
(Alternatively, if you have the UPDATE privilege for the grant tables
in the mysql system database, you can grant any account any privilege.)
When the read_only system variable is enabled, GRANT additionally
requires the SUPER privilege.
The REVOKE statement is related to GRANT and enables administrators to
remove account privileges. See [HELP REVOKE].
Each account name uses the format described in
https://dev.mysql.com/doc/refman/5.7/en/account-names.html. For
example:
GRANT ALL ON db1.* TO 'jeffrey'@'localhost';
The host name part of the account, if omitted, defaults to '%'.
Normally, a database administrator first uses CREATE USER to create an
account and define its nonprivilege characteristics such as its
password, whether it uses secure connections, and limits on access to
server resources, then uses GRANT to define its privileges. ALTER USER
may be used to change the nonprivilege characteristics of existing
accounts. For example:
CREATE USER 'jeffrey'@'localhost' IDENTIFIED BY 'password';
GRANT ALL ON db1.* TO 'jeffrey'@'localhost';
GRANT SELECT ON db2.invoice TO 'jeffrey'@'localhost';
ALTER USER 'jeffrey'@'localhost' WITH MAX_QUERIES_PER_HOUR 90;
*Note*:
Examples shown here include no IDENTIFIED clause. It is assumed that
you establish passwords with CREATE USER at account-creation time to
avoid creating insecure accounts.
*Note*:
If an account named in a GRANT statement does not already exist, GRANT
may create it under the conditions described later in the discussion of
the NO_AUTO_CREATE_USER SQL mode. It is also possible to use GRANT to
specify nonprivilege account characteristics such as whether it uses
secure connections and limits on access to server resources.
However, use of GRANT to create accounts or define nonprivilege
characteristics is deprecated in MySQL 5.7. Instead, perform these
tasks using CREATE USER or ALTER USER.
From the mysql program, GRANT responds with Query OK, 0 rows affected
when executed successfully. To determine what privileges result from
the operation, use SHOW GRANTS. See [HELP SHOW GRANTS].
URL: https://dev.mysql.com/doc/refman/5.7/en/grant.html
https://dev.mysql.com/doc/refman/5.7/en/grant.html8 q�@ J "� 6 xRENAME USER ,Syntax:
RENAME USER old_user TO new_user
[, old_user TO new_user] ...
The RENAME USER statement renames existing MySQL accounts. An error
occurs for old accounts that do not exist or new accounts that already
exist.
To use RENAME USER, you must have the global CREATE USER privilege, or
the UPDATE privilege for the mysql system database. When the read_only
system variable is enabled, RENAME USER additionally requires the SUPER
privilege.
Each account name uses the format described in
https://dev.mysql.com/doc/refman/5.7/en/account-names.html. For
example:
RENAME USER 'jeffrey'@'localhost' TO 'jeff'@'127.0.0.1';
The host name part of the account name, if omitted, defaults to '%'.
RENAME USER causes the privileges held by the old user to be those held
by the new user. However, RENAME USER does not automatically drop or
invalidate databases or objects within them that the old user created.
This includes stored programs or views for which the DEFINER attribute
names the old user. Attempts to access such objects may produce an
error if they execute in definer security context. (For information
about security context, see
https://dev.mysql.com/doc/refman/5.7/en/stored-objects-security.html.)
The privilege changes take effect as indicated in
https://dev.mysql.com/doc/refman/5.7/en/privilege-changes.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/rename-user.html
https://dev.mysql.com/doc/refman/5.7/en/rename-user.html3 S�@ � K "� 6 �REVOKE ,Syntax:
REVOKE
priv_type [(column_list)]
[, priv_type [(column_list)]] ...
ON [object_type] priv_level
FROM user [, user] ...
REVOKE ALL [PRIVILEGES], GRANT OPTION
FROM user [, user] ...
REVOKE PROXY ON user
FROM user [, user] ...
The REVOKE statement enables system administrators to revoke privileges
from MySQL accounts.
For details on the levels at which privileges exist, the permissible
priv_type, priv_level, and object_type values, and the syntax for
specifying users and passwords, see [HELP GRANT].
When the read_only system variable is enabled, REVOKE requires the
SUPER privilege in addition to any other required privileges described
in the following discussion.
Each account name uses the format described in
https://dev.mysql.com/doc/refman/5.7/en/account-names.html. For
example:
REVOKE INSERT ON *.* FROM 'jeffrey'@'localhost';
The host name part of the account name, if omitted, defaults to '%'.
To use the first REVOKE syntax, you must have the GRANT OPTION
privilege, and you must have the privileges that you are revoking.
To revoke all privileges, use the second syntax, which drops all
global, database, table, column, and routine privileges for the named
user or users:
REVOKE ALL PRIVILEGES, GRANT OPTION FROM user [, user] ...
To use this REVOKE syntax, you must have the global CREATE USER
privilege, or the UPDATE privilege for the mysql system database.
User accounts from which privileges are to be revoked must exist, but
the privileges to be revoked need not be currently granted to them.
URL: https://dev.mysql.com/doc/refman/5.7/en/revoke.html
https://dev.mysql.com/doc/refman/5.7/en/revoke.html9 �@ (� L "� 6 �SET PASSWORD ,Syntax:
SET PASSWORD [FOR user] = password_option
password_option: {
'auth_string'
| PASSWORD('auth_string')
}
The SET PASSWORD statement assigns a password to a MySQL user account.
'auth_string' represents a cleartext (unencrypted) password.
*Note*:
o SET PASSWORD ... = PASSWORD('auth_string') syntax is deprecated in
MySQL 5.7 and is removed in MySQL 8.0.
o SET PASSWORD ... = 'auth_string' syntax is not deprecated, but ALTER
USER is the preferred statement for account alterations, including
assigning passwords. For example:
ALTER USER user IDENTIFIED BY 'auth_string';
*Important*:
Under some circumstances, SET PASSWORD may be recorded in server logs
or on the client side in a history file such as ~/.mysql_history, which
means that cleartext passwords may be read by anyone having read access
to that information. For information about the conditions under which
this occurs for the server logs and how to control it, see
https://dev.mysql.com/doc/refman/5.7/en/password-logging.html. For
similar information about client-side logging, see
https://dev.mysql.com/doc/refman/5.7/en/mysql-logging.html.
SET PASSWORD can be used with or without a FOR clause that explicitly
names a user account:
o With a FOR user clause, the statement sets the password for the named
account, which must exist:
SET PASSWORD FOR 'jeffrey'@'localhost' = 'auth_string';
o With no FOR user clause, the statement sets the password for the
current user:
SET PASSWORD = 'auth_string';
Any client who connects to the server using a nonanonymous account
can change the password for that account. (In particular, you can
change your own password.) To see which account the server
authenticated you as, invoke the CURRENT_USER() function:
SELECT CURRENT_USER();
If a FOR user clause is given, the account name uses the format
described in
https://dev.mysql.com/doc/refman/5.7/en/account-names.html. For
example:
SET PASSWORD FOR 'bob'@'%.example.org' = 'auth_string';
The host name part of the account name, if omitted, defaults to '%'.
Setting the password for a named account (with a FOR clause) requires
the UPDATE privilege for the mysql system database. Setting the
password for yourself (for a nonanonymous account with no FOR clause)
requires no special privileges. When the read_only system variable is
enabled, SET PASSWORD requires the SUPER privilege in addition to any
other required privileges.
The password can be specified in these ways:
o Use a string without PASSWORD()
SET PASSWORD FOR 'jeffrey'@'localhost' = 'password';
SET PASSWORD interprets the string as a cleartext string, passes it
to the authentication plugin associated with the account, and stores
the result returned by the plugin in the account row in the
mysql.user system table. (The plugin is given the opportunity to hash
the value into the encryption format it expects. The plugin may use
the value as specified, in which case no hashing occurs.)
o Use the PASSWORD() function (deprecated in MySQL 5.7)
SET PASSWORD FOR 'jeffrey'@'localhost' = PASSWORD('password');
The PASSWORD() argument is the cleartext (unencrypted) password.
PASSWORD() hashes the password and returns the encrypted password
string for storage in the account row in the mysql.user system table.
The PASSWORD() function hashes the password using the hashing method
determined by the value of the old_passwords system variable value.
Be sure that old_passwords has the value corresponding to the hashing
method expected by the authentication plugin associated with the
account. For example, if the account uses the mysql_native_password
plugin, the old_passwords value must be 0:
SET old_passwords = 0;
SET PASSWORD FOR 'jeffrey'@'localhost' = PASSWORD('password');
If the old_passwords value differs from that required by the
authentication plugin, the hashed password value returned by
PASSWORD() cannot be used by the plugin and correct authentication of
client connections cannot occur.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-password.html
https://dev.mysql.com/doc/refman/5.7/en/set-password.html: ۅ@ 0r M "� 6 �ANALYZE TABLE -Syntax:
ANALYZE [NO_WRITE_TO_BINLOG | LOCAL]
TABLE tbl_name [, tbl_name] ...
ANALYZE TABLE performs a key distribution analysis and stores the
distribution for the named table or tables. For MyISAM tables, this
statement is equivalent to using myisamchk --analyze.
This statement requires SELECT and INSERT privileges for the table.
ANALYZE TABLE works with InnoDB, NDB, and MyISAM tables. It does not
work with views.
ANALYZE TABLE is supported for partitioned tables, and you can use
ALTER TABLE ... ANALYZE PARTITION to analyze one or more partitions;
for more information, see [HELP ALTER TABLE], and
https://dev.mysql.com/doc/refman/5.7/en/partitioning-maintenance.html.
During the analysis, the table is locked with a read lock for InnoDB
and MyISAM.
ANALYZE TABLE removes the table from the table definition cache, which
requires a flush lock. If there are long running statements or
transactions still using the table, subsequent statements and
transactions must wait for those operations to finish before the flush
lock is released. Because ANALYZE TABLE itself typically finishes
quickly, it may not be apparent that delayed transactions or statements
involving the same table are due to the remaining flush lock.
By default, the server writes ANALYZE TABLE statements to the binary
log so that they replicate to replicas. To suppress logging, specify
the optional NO_WRITE_TO_BINLOG keyword or its alias LOCAL.
URL: https://dev.mysql.com/doc/refman/5.7/en/analyze-table.html
https://dev.mysql.com/doc/refman/5.7/en/analyze-table.html8 �@ 8� N "� 6 �CHECK TABLE -Syntax:
CHECK TABLE tbl_name [, tbl_name] ... [option] ...
option: {
FOR UPGRADE
| QUICK
| FAST
| MEDIUM
| EXTENDED
| CHANGED
}
CHECK TABLE checks a table or tables for errors. For MyISAM tables, the
key statistics are updated as well. CHECK TABLE can also check views
for problems, such as tables that are referenced in the view definition
that no longer exist.
To check a table, you must have some privilege for it.
CHECK TABLE works for InnoDB, MyISAM, ARCHIVE, and CSV tables.
Before running CHECK TABLE on InnoDB tables, see
https://dev.mysql.com/doc/refman/5.7/en/check-table.html#check-table-in
nodb.
CHECK TABLE is supported for partitioned tables, and you can use ALTER
TABLE ... CHECK PARTITION to check one or more partitions; for more
information, see [HELP ALTER TABLE], and
https://dev.mysql.com/doc/refman/5.7/en/partitioning-maintenance.html.
CHECK TABLE ignores virtual generated columns that are not indexed.
URL: https://dev.mysql.com/doc/refman/5.7/en/check-table.html
https://dev.mysql.com/doc/refman/5.7/en/check-table.html; ��@ @� O "� 6 �CHECKSUM TABLE -Syntax:
CHECKSUM TABLE tbl_name [, tbl_name] ... [QUICK | EXTENDED]
CHECKSUM TABLE reports a checksum for the contents of a table. You can
use this statement to verify that the contents are the same before and
after a backup, rollback, or other operation that is intended to put
the data back to a known state.
This statement requires the SELECT privilege for the table.
This statement is not supported for views. If you run CHECKSUM TABLE
against a view, the Checksum value is always NULL, and a warning is
returned.
For a nonexistent table, CHECKSUM TABLE returns NULL and generates a
warning.
During the checksum operation, the table is locked with a read lock for
InnoDB and MyISAM.
URL: https://dev.mysql.com/doc/refman/5.7/en/checksum-table.html
https://dev.mysql.com/doc/refman/5.7/en/checksum-table.html p c�� ",���>E V U W "x�E� 80�
3� infimum supremum; �@
� P "� 6 �OPTIMIZE TABLE -Syntax:
OPTIMIZE [NO_WRITE_TO_BINLOG | LOCAL]
TABLE tbl_name [, tbl_name] ...
OPTIMIZE TABLE reorganizes the physical storage of table data and
associated index data, to reduce storage space and improve I/O
efficiency when accessing the table. The exact changes made to each
table depend on the storage engine used by that table.
Use OPTIMIZE TABLE in these cases, depending on the type of table:
o After doing substantial insert, update, or delete operations on an
InnoDB table that has its own .ibd file because it was created with
the innodb_file_per_table option enabled. The table and indexes are
reorganized, and disk space can be reclaimed for use by the operating
system.
o After doing substantial insert, update, or delete operations on
columns that are part of a FULLTEXT index in an InnoDB table. Set the
configuration option innodb_optimize_fulltext_only=1 first. To keep
the index maintenance period to a reasonable time, set the
innodb_ft_num_word_optimize option to specify how many words to
update in the search index, and run a sequence of OPTIMIZE TABLE
statements until the search index is fully updated.
o After deleting a large part of a MyISAM or ARCHIVE table, or making
many changes to a MyISAM or ARCHIVE table with variable-length rows
(tables that have VARCHAR, VARBINARY, BLOB, or TEXT columns). Deleted
rows are maintained in a linked list and subsequent INSERT operations
reuse old row positions. You can use OPTIMIZE TABLE to reclaim the
unused space and to defragment the data file. After extensive changes
to a table, this statement may also improve performance of statements
that use the table, sometimes significantly.
This statement requires SELECT and INSERT privileges for the table.
OPTIMIZE TABLE works for InnoDB, MyISAM, and ARCHIVE tables. OPTIMIZE
TABLE is also supported for dynamic columns of in-memory NDB tables. It
does not work for fixed-width columns of in-memory tables, nor does it
work for Disk Data tables. The performance of OPTIMIZE on NDB Cluster
tables can be tuned using --ndb-optimization-delay, which controls the
length of time to wait between processing batches of rows by OPTIMIZE
TABLE. For more information, see Previous NDB Cluster Issues Resolved
in NDB Cluster 8.0
(https://dev.mysql.com/doc/refman/8.0/en/mysql-cluster-limitations-reso
lved.html).
For NDB Cluster tables, OPTIMIZE TABLE can be interrupted by (for
example) killing the SQL thread performing the OPTIMIZE operation.
By default, OPTIMIZE TABLE does not work for tables created using any
other storage engine and returns a result indicating this lack of
support. You can make OPTIMIZE TABLE work for other storage engines by
starting mysqld with the --skip-new option. In this case, OPTIMIZE
TABLE is just mapped to ALTER TABLE.
This statement does not work with views.
OPTIMIZE TABLE is supported for partitioned tables. For information
about using this statement with partitioned tables and table
partitions, see
https://dev.mysql.com/doc/refman/5.7/en/partitioning-maintenance.html.
By default, the server writes OPTIMIZE TABLE statements to the binary
log so that they replicate to replicas. To suppress logging, specify
the optional NO_WRITE_TO_BINLOG keyword or its alias LOCAL.
URL: https://dev.mysql.com/doc/refman/5.7/en/optimize-table.html
https://dev.mysql.com/doc/refman/5.7/en/optimize-table.html9 f�@ � Q "� 6 �REPAIR TABLE -Syntax:
REPAIR [NO_WRITE_TO_BINLOG | LOCAL]
TABLE tbl_name [, tbl_name] ...
[QUICK] [EXTENDED] [USE_FRM]
REPAIR TABLE repairs a possibly corrupted table, for certain storage
engines only.
This statement requires SELECT and INSERT privileges for the table.
Although normally you should never have to run REPAIR TABLE, if
disaster strikes, this statement is very likely to get back all your
data from a MyISAM table. If your tables become corrupted often, try to
find the reason for it, to eliminate the need to use REPAIR TABLE. See
https://dev.mysql.com/doc/refman/5.7/en/crashing.html, and
https://dev.mysql.com/doc/refman/5.7/en/myisam-table-problems.html.
REPAIR TABLE checks the table to see whether an upgrade is required. If
so, it performs the upgrade, following the same rules as CHECK TABLE
... FOR UPGRADE. See [HELP CHECK TABLE], for more information.
*Important*:
o Make a backup of a table before performing a table repair operation;
under some circumstances the operation might cause data loss.
Possible causes include but are not limited to file system errors.
See https://dev.mysql.com/doc/refman/5.7/en/backup-and-recovery.html.
o If the server exits during a REPAIR TABLE operation, it is essential
after restarting it that you immediately execute another REPAIR TABLE
statement for the table before performing any other operations on it.
In the worst case, you might have a new clean index file without
information about the data file, and then the next operation you
perform could overwrite the data file. This is an unlikely but
possible scenario that underscores the value of making a backup
first.
o In the event that a table on the source becomes corrupted and you run
REPAIR TABLE on it, any resulting changes to the original table are
not propagated to replicas.
URL: https://dev.mysql.com/doc/refman/5.7/en/repair-table.html
https://dev.mysql.com/doc/refman/5.7/en/repair-table.htmlE �@ � R "� 6 �CREATE FUNCTION LOADABLE FUNCTION .Syntax:
CREATE [AGGREGATE] FUNCTION function_name
RETURNS {STRING|INTEGER|REAL|DECIMAL}
SONAME shared_library_name
This statement loads the loadable function named function_name. (CREATE
FUNCTION is also used to created stored functions; see [HELP CREATE
PROCEDURE].)
A loadable function is a way to extend MySQL with a new function that
works like a native (built-in) MySQL function such as ABS() or
CONCAT(). See Adding a Loadable Function
(https://dev.mysql.com/doc/extending-mysql/5.7/en/adding-loadable-funct
ion.html).
function_name is the name that should be used in SQL statements to
invoke the function. The RETURNS clause indicates the type of the
function's return value. DECIMAL is a legal value after RETURNS, but
currently DECIMAL functions return string values and should be written
like STRING functions.
The AGGREGATE keyword, if given, signifies that the function is an
aggregate (group) function. An aggregate function works exactly like a
native MySQL aggregate function such as SUM() or COUNT().
shared_library_name is the base name of the shared library file
containing the code that implements the function. The file must be
located in the plugin directory. This directory is given by the value
of the plugin_dir system variable. For more information, see
https://dev.mysql.com/doc/refman/5.7/en/function-loading.html.
CREATE FUNCTION requires the INSERT privilege for the mysql system
database because it adds a row to the mysql.func system table to
register the function.
During the normal startup sequence, the server loads functions
registered in the mysql.func table. If the server is started with the
--skip-grant-tables option, functions registered in the table are not
loaded and are unavailable.
URL: https://dev.mysql.com/doc/refman/5.7/en/create-function-loadable.html
https://dev.mysql.com/doc/refman/5.7/en/create-function-loadable.htmlC ̂@ (l S "� 6 �DROP FUNCTION LOADABLE FUNCTION .Syntax:
DROP FUNCTION [IF EXISTS] function_name
This statement drops the loadable function named function_name. (DROP
FUNCTION is also used to drop stored functions; see [HELP DROP
PROCEDURE].)
DROP FUNCTION is the complement of CREATE FUNCTION. It requires the
DELETE privilege for the mysql system database because it removes the
row from the mysql.func system table that registers the function.
During the normal startup sequence, the server loads functions
registered in the mysql.func table. Because DROP FUNCTION removes the
mysql.func row for the dropped function, the server does not load the
function during subsequent restarts.
URL: https://dev.mysql.com/doc/refman/5.7/en/drop-function-loadable.html
https://dev.mysql.com/doc/refman/5.7/en/drop-function-loadable.html; ��@ 0 ' T "� 6 �INSTALL PLUGIN /Syntax:
INSTALL PLUGIN plugin_name SONAME 'shared_library_name'
This statement installs a server plugin. It requires the INSERT
privilege for the mysql.plugin system table because it adds a row to
that table to register the plugin.
plugin_name is the name of the plugin as defined in the plugin
descriptor structure contained in the library file (see Plugin Data
Structures
(https://dev.mysql.com/doc/extending-mysql/5.7/en/plugin-data-structure
s.html)). Plugin names are not case-sensitive. For maximal
compatibility, plugin names should be limited to ASCII letters, digits,
and underscore because they are used in C source files, shell command
lines, M4 and Bourne shell scripts, and SQL environments.
shared_library_name is the name of the shared library that contains the
plugin code. The name includes the file name extension (for example,
libmyplugin.so, libmyplugin.dll, or libmyplugin.dylib).
The shared library must be located in the plugin directory (the
directory named by the plugin_dir system variable). The library must be
in the plugin directory itself, not in a subdirectory. By default,
plugin_dir is the plugin directory under the directory named by the
pkglibdir configuration variable, but it can be changed by setting the
value of plugin_dir at server startup. For example, set its value in a
my.cnf file:
[mysqld]
plugin_dir=/path/to/plugin/directory
If the value of plugin_dir is a relative path name, it is taken to be
relative to the MySQL base directory (the value of the basedir system
variable).
INSTALL PLUGIN loads and initializes the plugin code to make the plugin
available for use. A plugin is initialized by executing its
initialization function, which handles any setup that the plugin must
perform before it can be used. When the server shuts down, it executes
the deinitialization function for each plugin that is loaded so that
the plugin has a chance to perform any final cleanup.
INSTALL PLUGIN also registers the plugin by adding a line that
indicates the plugin name and library file name to the mysql.plugin
system table. During the normal startup sequence, the server loads and
initializes plugins registered in mysql.plugin. This means that a
plugin is installed with INSTALL PLUGIN only once, not every time the
server starts. If the server is started with the --skip-grant-tables
option, plugins registered in the mysql.plugin table are not loaded and
are unavailable.
A plugin library can contain multiple plugins. For each of them to be
installed, use a separate INSTALL PLUGIN statement. Each statement
names a different plugin, but all of them specify the same library
name.
URL: https://dev.mysql.com/doc/refman/5.7/en/install-plugin.html
https://dev.mysql.com/doc/refman/5.7/en/install-plugin.html= Â@ 8] U "� 6!UNINSTALL PLUGIN /Syntax:
UNINSTALL PLUGIN plugin_name
This statement removes an installed server plugin. UNINSTALL PLUGIN is
the complement of INSTALL PLUGIN. It requires the DELETE privilege for
the mysql.plugin system table because it removes the row from that
table that registers the plugin.
plugin_name must be the name of some plugin that is listed in the
mysql.plugin table. The server executes the plugin's deinitialization
function and removes the row for the plugin from the mysql.plugin
system table, so that subsequent server restarts do not load and
initialize the plugin. UNINSTALL PLUGIN does not remove the plugin's
shared library file.
URL: https://dev.mysql.com/doc/refman/5.7/en/uninstall-plugin.html
https://dev.mysql.com/doc/refman/5.7/en/uninstall-plugin.html9 ��@ @+ V "� 6!SET Syntax:
SET variable = expr [, variable = expr] ...
variable: {
user_var_name
| param_name
| local_var_name
| {GLOBAL | @@GLOBAL.} system_var_name
| [SESSION | @@SESSION. | @@] system_var_name
}
SET syntax for variable assignment enables you to assign values to
different types of variables that affect the operation of the server or
clients:
o User-defined variables. See
https://dev.mysql.com/doc/refman/5.7/en/user-variables.html.
o Stored procedure and function parameters, and stored program local
variables. See
https://dev.mysql.com/doc/refman/5.7/en/stored-program-variables.html
.
o System variables. See
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
System variables also can be set at server startup, as described in
https://dev.mysql.com/doc/refman/5.7/en/using-system-variables.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-variable.html
https://dev.mysql.com/doc/refman/5.7/en/set-variable.html> ��@ H�y W "� 6!!SET CHARACTER SET Syntax:
SET {CHARACTER SET | CHARSET}
{'charset_name' | DEFAULT}
This statement maps all strings sent between the server and the current
client with the given mapping. SET CHARACTER SET sets three session
system variables: character_set_client and character_set_results are
set to the given character set, and character_set_connection to the
value of character_set_database. See
https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html.
charset_name may be quoted or unquoted.
The default character set mapping can be restored by using the value
DEFAULT. The default depends on the server configuration.
Some character sets cannot be used as the client character set.
Attempting to use them with SET CHARACTER SET produces an error. See
https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html#charset
-connection-impermissible-client-charset.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-character-set.html
https://dev.mysql.com/doc/refman/5.7/en/set-character-set.html p � c��>E "x�6�� W V X "��E� 78� $} infimum supremum> ��@ C X "� 6!.SET CHARSET Syntax:
SET {CHARACTER SET | CHARSET}
{'charset_name' | DEFAULT}
This statement maps all strings sent between the server and the current
client with the given mapping. SET CHARACTER SET sets three session
system variables: character_set_client and character_set_results are
set to the given character set, and character_set_connection to the
value of character_set_database. See
https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html.
charset_name may be quoted or unquoted.
The default character set mapping can be restored by using the value
DEFAULT. The default depends on the server configuration.
Some character sets cannot be used as the client character set.
Attempting to use them with SET CHARACTER SET produces an error. See
https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html#charset
-connection-impermissible-client-charset.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-character-set.html
https://dev.mysql.com/doc/refman/5.7/en/set-character-set.html6 "�@ � Y "� 6!;SET NAMES Syntax:
SET NAMES {'charset_name'
[COLLATE 'collation_name'] | DEFAULT}
This statement sets the three session system variables
character_set_client, character_set_connection, and
character_set_results to the given character set. Setting
character_set_connection to charset_name also sets collation_connection
to the default collation for charset_name. See
https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html.
The optional COLLATE clause may be used to specify a collation
explicitly. If given, the collation must one of the permitted
collations for charset_name.
charset_name and collation_name may be quoted or unquoted.
The default mapping can be restored by using a value of DEFAULT. The
default depends on the server configuration.
Some character sets cannot be used as the client character set.
Attempting to use them with SET NAMES produces an error. See
https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html#charset
-connection-impermissible-client-charset.
URL: https://dev.mysql.com/doc/refman/5.7/en/set-names.html
https://dev.mysql.com/doc/refman/5.7/en/set-names.html1 !�@ � Z "� 6!HSHOW SHOW has many forms that provide information about databases, tables,
columns, or status information about the server. This section describes
those following:
SHOW {BINARY | MASTER} LOGS
SHOW BINLOG EVENTS [IN 'log_name'] [FROM pos] [LIMIT [offset,] row_count]
SHOW {CHARACTER SET | CHARSET} [like_or_where]
SHOW COLLATION [like_or_where]
SHOW [FULL] COLUMNS FROM tbl_name [FROM db_name] [like_or_where]
SHOW CREATE DATABASE db_name
SHOW CREATE EVENT event_name
SHOW CREATE FUNCTION func_name
SHOW CREATE PROCEDURE proc_name
SHOW CREATE TABLE tbl_name
SHOW CREATE TRIGGER trigger_name
SHOW CREATE VIEW view_name
SHOW DATABASES [like_or_where]
SHOW ENGINE engine_name {STATUS | MUTEX}
SHOW [STORAGE] ENGINES
SHOW ERRORS [LIMIT [offset,] row_count]
SHOW EVENTS
SHOW FUNCTION CODE func_name
SHOW FUNCTION STATUS [like_or_where]
SHOW GRANTS FOR user
SHOW INDEX FROM tbl_name [FROM db_name]
SHOW MASTER STATUS
SHOW OPEN TABLES [FROM db_name] [like_or_where]
SHOW PLUGINS
SHOW PROCEDURE CODE proc_name
SHOW PROCEDURE STATUS [like_or_where]
SHOW PRIVILEGES
SHOW [FULL] PROCESSLIST
SHOW PROFILE [types] [FOR QUERY n] [OFFSET n] [LIMIT n]
SHOW PROFILES
SHOW RELAYLOG EVENTS [IN 'log_name'] [FROM pos] [LIMIT [offset,] row_count]
SHOW SLAVE HOSTS
SHOW SLAVE STATUS [FOR CHANNEL channel]
SHOW [GLOBAL | SESSION] STATUS [like_or_where]
SHOW TABLE STATUS [FROM db_name] [like_or_where]
SHOW [FULL] TABLES [FROM db_name] [like_or_where]
SHOW TRIGGERS [FROM db_name] [like_or_where]
SHOW [GLOBAL | SESSION] VARIABLES [like_or_where]
SHOW WARNINGS [LIMIT [offset,] row_count]
like_or_where: {
LIKE 'pattern'
| WHERE expr
}
If the syntax for a given SHOW statement includes a LIKE 'pattern'
part, 'pattern' is a string that can contain the SQL % and _ wildcard
characters. The pattern is useful for restricting statement output to
matching values.
Several SHOW statements also accept a WHERE clause that provides more
flexibility in specifying which rows to display. See
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show.html
https://dev.mysql.com/doc/refman/5.7/en/show.html= G�@ (� [ "� 6!USHOW BINARY LOGS Syntax:
SHOW BINARY LOGS
SHOW MASTER LOGS
Lists the binary log files on the server. This statement is used as
part of the procedure described in [HELP PURGE BINARY LOGS], that shows
how to determine which logs can be purged. A user with the SUPER or
REPLICATION CLIENT privilege may execute this statement.
mysql> SHOW BINARY LOGS;
+---------------+-----------+
| Log_name | File_size |
+---------------+-----------+
| binlog.000015 | 724935 |
| binlog.000016 | 733481 |
+---------------+-----------+
URL: https://dev.mysql.com/doc/refman/5.7/en/show-binary-logs.html
https://dev.mysql.com/doc/refman/5.7/en/show-binary-logs.html= G�@ 0� \ "� 6!bSHOW MASTER LOGS Syntax:
SHOW BINARY LOGS
SHOW MASTER LOGS
Lists the binary log files on the server. This statement is used as
part of the procedure described in [HELP PURGE BINARY LOGS], that shows
how to determine which logs can be purged. A user with the SUPER or
REPLICATION CLIENT privilege may execute this statement.
mysql> SHOW BINARY LOGS;
+---------------+-----------+
| Log_name | File_size |
+---------------+-----------+
| binlog.000015 | 724935 |
| binlog.000016 | 733481 |
+---------------+-----------+
URL: https://dev.mysql.com/doc/refman/5.7/en/show-binary-logs.html
https://dev.mysql.com/doc/refman/5.7/en/show-binary-logs.html? I�@ 8� ] "� 6!oSHOW BINLOG EVENTS Syntax:
SHOW BINLOG EVENTS
[IN 'log_name']
[FROM pos]
[LIMIT [offset,] row_count]
Shows the events in the binary log. If you do not specify 'log_name',
the first binary log is displayed. SHOW BINLOG EVENTS requires the
REPLICATION SLAVE privilege.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-binlog-events.html
https://dev.mysql.com/doc/refman/5.7/en/show-binlog-events.html? (�@ @� ^ "� 6!|SHOW CHARACTER SET Syntax:
SHOW {CHARACTER SET | CHARSET}
[LIKE 'pattern' | WHERE expr]
The SHOW CHARACTER SET statement shows all available character sets.
The LIKE clause, if present, indicates which character set names to
match. The WHERE clause can be given to select rows using more general
conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html. For
example:
mysql> SHOW CHARACTER SET LIKE 'latin%';
+---------+-----------------------------+-------------------+--------+
| Charset | Description | Default collation | Maxlen |
+---------+-----------------------------+-------------------+--------+
| latin1 | cp1252 West European | latin1_swedish_ci | 1 |
| latin2 | ISO 8859-2 Central European | latin2_general_ci | 1 |
| latin5 | ISO 8859-9 Turkish | latin5_turkish_ci | 1 |
| latin7 | ISO 8859-13 Baltic | latin7_general_ci | 1 |
+---------+-----------------------------+-------------------+--------+
URL: https://dev.mysql.com/doc/refman/5.7/en/show-character-set.html
https://dev.mysql.com/doc/refman/5.7/en/show-character-set.html; Q�@ H� _ "� 6!�SHOW COLLATION Syntax:
SHOW COLLATION
[LIKE 'pattern' | WHERE expr]
This statement lists collations supported by the server. By default,
the output from SHOW COLLATION includes all available collations. The
LIKE clause, if present, indicates which collation names to match. The
WHERE clause can be given to select rows using more general conditions,
as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html. For
example:
mysql> SHOW COLLATION WHERE Charset = 'latin1';
+-------------------+---------+----+---------+----------+---------+
| Collation | Charset | Id | Default | Compiled | Sortlen |
+-------------------+---------+----+---------+----------+---------+
| latin1_german1_ci | latin1 | 5 | | Yes | 1 |
| latin1_swedish_ci | latin1 | 8 | Yes | Yes | 1 |
| latin1_danish_ci | latin1 | 15 | | Yes | 1 |
| latin1_german2_ci | latin1 | 31 | | Yes | 2 |
| latin1_bin | latin1 | 47 | | Yes | 1 |
| latin1_general_ci | latin1 | 48 | | Yes | 1 |
| latin1_general_cs | latin1 | 49 | | Yes | 1 |
| latin1_spanish_ci | latin1 | 94 | | Yes | 1 |
+-------------------+---------+----+---------+----------+---------+
URL: https://dev.mysql.com/doc/refman/5.7/en/show-collation.html
https://dev.mysql.com/doc/refman/5.7/en/show-collation.html9 /�@ P�� ` "� 6!�SHOW COLUMNS Syntax:
SHOW [FULL] {COLUMNS | FIELDS}
{FROM | IN} tbl_name
[{FROM | IN} db_name]
[LIKE 'pattern' | WHERE expr]
SHOW COLUMNS displays information about the columns in a given table.
It also works for views. SHOW COLUMNS displays information only for
those columns for which you have some privilege.
mysql> SHOW COLUMNS FROM City;
+-------------+----------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+----------+------+-----+---------+----------------+
| ID | int(11) | NO | PRI | NULL | auto_increment |
| Name | char(35) | NO | | | |
| CountryCode | char(3) | NO | MUL | | |
| District | char(20) | NO | | | |
| Population | int(11) | NO | | 0 | |
+-------------+----------+------+-----+---------+----------------+
An alternative to tbl_name FROM db_name syntax is db_name.tbl_name.
These two statements are equivalent:
SHOW COLUMNS FROM mytable FROM mydb;
SHOW COLUMNS FROM mydb.mytable;
The optional FULL keyword causes the output to include the column
collation and comments, as well as the privileges you have for each
column.
The LIKE clause, if present, indicates which column names to match. The
WHERE clause can be given to select rows using more general conditions,
as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
The data types may differ from what you expect them to be based on a
CREATE TABLE statement because MySQL sometimes changes data types when
you create or alter a table. The conditions under which this occurs are
described in
https://dev.mysql.com/doc/refman/5.7/en/silent-column-changes.html.
SHOW COLUMNS displays the following values for each table column:
o Field
The column name.
o Type
The column data type.
o Collation
The collation for nonbinary string columns, or NULL for other
columns. This value is displayed only if you use the FULL keyword.
o Null
The column nullability. The value is YES if NULL values can be stored
in the column, NO if not.
o Key
Whether the column is indexed:
o If Key is empty, the column either is not indexed or is indexed
only as a secondary column in a multiple-column, nonunique index.
o If Key is PRI, the column is a PRIMARY KEY or is one of the columns
in a multiple-column PRIMARY KEY.
o If Key is UNI, the column is the first column of a UNIQUE index. (A
UNIQUE index permits multiple NULL values, but you can tell whether
the column permits NULL by checking the Null field.)
o If Key is MUL, the column is the first column of a nonunique index
in which multiple occurrences of a given value are permitted within
the column.
If more than one of the Key values applies to a given column of a
table, Key displays the one with the highest priority, in the order
PRI, UNI, MUL.
A UNIQUE index may be displayed as PRI if it cannot contain NULL
values and there is no PRIMARY KEY in the table. A UNIQUE index may
display as MUL if several columns form a composite UNIQUE index;
although the combination of the columns is unique, each column can
still hold multiple occurrences of a given value.
o Default
The default value for the column. This is NULL if the column has an
explicit default of NULL, or if the column definition includes no
DEFAULT clause.
o Extra
Any additional information that is available about a given column.
The value is nonempty in these cases:
o auto_increment for columns that have the AUTO_INCREMENT attribute.
o on update CURRENT_TIMESTAMP for TIMESTAMP or DATETIME columns that
have the ON UPDATE CURRENT_TIMESTAMP attribute.
o VIRTUAL GENERATED or STORED GENERATED for generated columns.
o Privileges
The privileges you have for the column. This value is displayed only
if you use the FULL keyword.
o Comment
Any comment included in the column definition. This value is
displayed only if you use the FULL keyword.
Table column information is also available from the INFORMATION_SCHEMA
COLUMNS table. See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-columns-tabl
e.html.
You can list a table's columns with the mysqlshow db_name tbl_name
command.
The DESCRIBE statement provides information similar to SHOW COLUMNS.
See https://dev.mysql.com/doc/refman/5.7/en/describe.html.
The SHOW CREATE TABLE, SHOW TABLE STATUS, and SHOW INDEX statements
also provide information about tables. See [HELP SHOW].
URL: https://dev.mysql.com/doc/refman/5.7/en/show-columns.html
https://dev.mysql.com/doc/refman/5.7/en/show-columns.html p) c6�� "���tT X W Y #E� 9̀ 8�
infimum supremum9 /�@ � a "� 6!�SHOW FIELDS Syntax:
SHOW [FULL] {COLUMNS | FIELDS}
{FROM | IN} tbl_name
[{FROM | IN} db_name]
[LIKE 'pattern' | WHERE expr]
SHOW COLUMNS displays information about the columns in a given table.
It also works for views. SHOW COLUMNS displays information only for
those columns for which you have some privilege.
mysql> SHOW COLUMNS FROM City;
+-------------+----------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+----------+------+-----+---------+----------------+
| ID | int(11) | NO | PRI | NULL | auto_increment |
| Name | char(35) | NO | | | |
| CountryCode | char(3) | NO | MUL | | |
| District | char(20) | NO | | | |
| Population | int(11) | NO | | 0 | |
+-------------+----------+------+-----+---------+----------------+
An alternative to tbl_name FROM db_name syntax is db_name.tbl_name.
These two statements are equivalent:
SHOW COLUMNS FROM mytable FROM mydb;
SHOW COLUMNS FROM mydb.mytable;
The optional FULL keyword causes the output to include the column
collation and comments, as well as the privileges you have for each
column.
The LIKE clause, if present, indicates which column names to match. The
WHERE clause can be given to select rows using more general conditions,
as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
The data types may differ from what you expect them to be based on a
CREATE TABLE statement because MySQL sometimes changes data types when
you create or alter a table. The conditions under which this occurs are
described in
https://dev.mysql.com/doc/refman/5.7/en/silent-column-changes.html.
SHOW COLUMNS displays the following values for each table column:
o Field
The column name.
o Type
The column data type.
o Collation
The collation for nonbinary string columns, or NULL for other
columns. This value is displayed only if you use the FULL keyword.
o Null
The column nullability. The value is YES if NULL values can be stored
in the column, NO if not.
o Key
Whether the column is indexed:
o If Key is empty, the column either is not indexed or is indexed
only as a secondary column in a multiple-column, nonunique index.
o If Key is PRI, the column is a PRIMARY KEY or is one of the columns
in a multiple-column PRIMARY KEY.
o If Key is UNI, the column is the first column of a UNIQUE index. (A
UNIQUE index permits multiple NULL values, but you can tell whether
the column permits NULL by checking the Null field.)
o If Key is MUL, the column is the first column of a nonunique index
in which multiple occurrences of a given value are permitted within
the column.
If more than one of the Key values applies to a given column of a
table, Key displays the one with the highest priority, in the order
PRI, UNI, MUL.
A UNIQUE index may be displayed as PRI if it cannot contain NULL
values and there is no PRIMARY KEY in the table. A UNIQUE index may
display as MUL if several columns form a composite UNIQUE index;
although the combination of the columns is unique, each column can
still hold multiple occurrences of a given value.
o Default
The default value for the column. This is NULL if the column has an
explicit default of NULL, or if the column definition includes no
DEFAULT clause.
o Extra
Any additional information that is available about a given column.
The value is nonempty in these cases:
o auto_increment for columns that have the AUTO_INCREMENT attribute.
o on update CURRENT_TIMESTAMP for TIMESTAMP or DATETIME columns that
have the ON UPDATE CURRENT_TIMESTAMP attribute.
o VIRTUAL GENERATED or STORED GENERATED for generated columns.
o Privileges
The privileges you have for the column. This value is displayed only
if you use the FULL keyword.
o Comment
Any comment included in the column definition. This value is
displayed only if you use the FULL keyword.
Table column information is also available from the INFORMATION_SCHEMA
COLUMNS table. See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-columns-tabl
e.html.
You can list a table's columns with the mysqlshow db_name tbl_name
command.
The DESCRIBE statement provides information similar to SHOW COLUMNS.
See https://dev.mysql.com/doc/refman/5.7/en/describe.html.
The SHOW CREATE TABLE, SHOW TABLE STATUS, and SHOW INDEX statements
also provide information about tables. See [HELP SHOW].
URL: https://dev.mysql.com/doc/refman/5.7/en/show-columns.html
https://dev.mysql.com/doc/refman/5.7/en/show-columns.htmlA��h�@ � b "� 6!�SHOW CREATE DATABASE Syntax:
SHOW CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
Shows the CREATE DATABASE statement that creates the named database. If
the SHOW statement includes an IF NOT EXISTS clause, the output too
includes such a clause. SHOW CREATE SCHEMA is a synonym for SHOW CREATE
DATABASE.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-database.html
mysql> SHOW CREATE DATABASE test\G
*************************** 1. row ***************************
Database: test
Create Database: CREATE DATABASE `test`
/*!40100 DEFAULT CHARACTER SET latin1 */
mysql> SHOW CREATE SCHEMA test\G
*************************** 1. row ***************************
Database: test
Create Database: CREATE DATABASE `test`
/*!40100 DEFAULT CHARACTER SET latin1 */
https://dev.mysql.com/doc/refman/5.7/en/show-create-database.htmlA��h�@ � c "� 6!�SHOW CREATE SCHEMA Syntax:
SHOW CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
Shows the CREATE DATABASE statement that creates the named database. If
the SHOW statement includes an IF NOT EXISTS clause, the output too
includes such a clause. SHOW CREATE SCHEMA is a synonym for SHOW CREATE
DATABASE.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-database.html
mysql> SHOW CREATE DATABASE test\G
*************************** 1. row ***************************
Database: test
Create Database: CREATE DATABASE `test`
/*!40100 DEFAULT CHARACTER SET latin1 */
mysql> SHOW CREATE SCHEMA test\G
*************************** 1. row ***************************
Database: test
Create Database: CREATE DATABASE `test`
/*!40100 DEFAULT CHARACTER SET latin1 */
https://dev.mysql.com/doc/refman/5.7/en/show-create-database.html>��s�@ (� d "� 6!�SHOW CREATE EVENT Syntax:
SHOW CREATE EVENT event_name
This statement displays the CREATE EVENT statement needed to re-create
a given event. It requires the EVENT privilege for the database from
which the event is to be shown. For example (using the same event
e_daily defined and then altered in [HELP SHOW EVENTS]):
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-event.html
mysql> SHOW CREATE EVENT myschema.e_daily\G
*************************** 1. row ***************************
Event: e_daily
sql_mode: ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,
NO_ZERO_IN_DATE,NO_ZERO_DATE,
ERROR_FOR_DIVISION_BY_ZERO,
NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
time_zone: SYSTEM
Create Event: CREATE DEFINER=`jon`@`ghidora` EVENT `e_daily`
ON SCHEDULE EVERY 1 DAY
STARTS CURRENT_TIMESTAMP + INTERVAL 6 HOUR
ON COMPLETION NOT PRESERVE
ENABLE
COMMENT 'Saves total number of sessions then
clears the table each day'
DO BEGIN
INSERT INTO site_activity.totals (time, total)
SELECT CURRENT_TIMESTAMP, COUNT(*)
FROM site_activity.sessions;
DELETE FROM site_activity.sessions;
END
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
https://dev.mysql.com/doc/refman/5.7/en/show-create-event.htmlA �@ 0 e "� 6!�SHOW CREATE FUNCTION Syntax:
SHOW CREATE FUNCTION func_name
This statement is similar to SHOW CREATE PROCEDURE but for stored
functions. See [HELP SHOW CREATE PROCEDURE].
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-function.html
https://dev.mysql.com/doc/refman/5.7/en/show-create-function.htmlBۅp�@ 8� f "� 6!�SHOW CREATE PROCEDURE Syntax:
SHOW CREATE PROCEDURE proc_name
This statement is a MySQL extension. It returns the exact string that
can be used to re-create the named stored procedure. A similar
statement, SHOW CREATE FUNCTION, displays information about stored
functions (see [HELP SHOW CREATE FUNCTION]).
To use either statement, you must be the user named in the routine
DEFINER clause or have SELECT access to the mysql.proc table. If you do
not have privileges for the routine itself, the value displayed for the
Create Procedure or Create Function column is NULL.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-procedure.html
mysql> SHOW CREATE PROCEDURE test.citycount\G
*************************** 1. row ***************************
Procedure: citycount
sql_mode: ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,
NO_ZERO_IN_DATE,NO_ZERO_DATE,
ERROR_FOR_DIVISION_BY_ZERO,
NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
Create Procedure: CREATE DEFINER=`me`@`localhost`
PROCEDURE `citycount`(IN country CHAR(3), OUT cities INT)
BEGIN
SELECT COUNT(*) INTO cities FROM world.city
WHERE CountryCode = country;
END
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
mysql> SHOW CREATE FUNCTION test.hello\G
*************************** 1. row ***************************
Function: hello
sql_mode: ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,
NO_ZERO_IN_DATE,NO_ZERO_DATE,
ERROR_FOR_DIVISION_BY_ZERO,
NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
Create Function: CREATE DEFINER=`me`@`localhost`
FUNCTION `hello`(s CHAR(20))
RETURNS char(50) CHARSET latin1
DETERMINISTIC
RETURN CONCAT('Hello, ',s,'!')
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
https://dev.mysql.com/doc/refman/5.7/en/show-create-procedure.html>z���@ @� g "� 6!�SHOW CREATE TABLE Syntax:
SHOW CREATE TABLE tbl_name
Shows the CREATE TABLE statement that creates the named table. To use
this statement, you must have some privilege for the table. This
statement also works with views.
SHOW CREATE TABLE quotes table and column names according to the value
of the sql_quote_show_create option. See
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
When altering the storage engine of a table, table options that are not
applicable to the new storage engine are retained in the table
definition to enable reverting the table with its previously defined
options to the original storage engine, if necessary. For example, when
changing the storage engine from InnoDB to MyISAM, InnoDB-specific
options such as ROW_FORMAT=COMPACT are retained.
When creating a table with strict mode disabled, the storage engine's
default row format is used if the specified row format is not
supported. The actual row format of the table is reported in the
Row_format column in response to SHOW TABLE STATUS. SHOW CREATE TABLE
shows the row format that was specified in the CREATE TABLE statement.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-table.html
mysql> SHOW CREATE TABLE t\G
*************************** 1. row ***************************
Table: t
Create Table: CREATE TABLE `t` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`s` char(60) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1
mysql> CREATE TABLE t1 (c1 INT PRIMARY KEY) ROW_FORMAT=COMPACT ENGINE=InnoDB;
mysql> ALTER TABLE t1 ENGINE=MyISAM;
mysql> SHOW CREATE TABLE t1\G
*************************** 1. row ***************************
Table: t1
Create Table: CREATE TABLE `t1` (
`c1` int(11) NOT NULL,
PRIMARY KEY (`c1`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ROW_FORMAT=COMPACT
https://dev.mysql.com/doc/refman/5.7/en/show-create-table.html@ �@ H� h "� 6!�SHOW CREATE TRIGGER Syntax:
SHOW CREATE TRIGGER trigger_name
This statement shows the CREATE TRIGGER statement that creates the
named trigger. This statement requires the TRIGGER privilege for the
table associated with the trigger.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-trigger.html
https://dev.mysql.com/doc/refman/5.7/en/show-create-trigger.html= ��@ P# i "� 6" SHOW CREATE USER Syntax:
SHOW CREATE USER user
This statement shows the CREATE USER statement that creates the named
user. An error occurs if the user does not exist. The statement
requires the SELECT privilege for the mysql system database, except to
display information for the current user.
To name the account, use the format described in
https://dev.mysql.com/doc/refman/5.7/en/account-names.html. The host
name part of the account name, if omitted, defaults to '%'. It is also
possible to specify CURRENT_USER or CURRENT_USER() to refer to the
account associated with the current session.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-user.html
https://dev.mysql.com/doc/refman/5.7/en/show-create-user.html= ��@ X�� j "� 6"SHOW CREATE VIEW Syntax:
SHOW CREATE VIEW view_name
This statement shows the CREATE VIEW statement that creates the named
view.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-create-view.html
https://dev.mysql.com/doc/refman/5.7/en/show-create-view.html p� c�tT #^��� Y X [ #SqE� ;�� 8� infimum supremum; ��@ k "� 6"%SHOW DATABASES Syntax:
SHOW {DATABASES | SCHEMAS}
[LIKE 'pattern' | WHERE expr]
SHOW DATABASES lists the databases on the MySQL server host. SHOW
SCHEMAS is a synonym for SHOW DATABASES. The LIKE clause, if present,
indicates which database names to match. The WHERE clause can be given
to select rows using more general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
You see only those databases for which you have some kind of privilege,
unless you have the global SHOW DATABASES privilege. You can also get
this list using the mysqlshow command.
If the server was started with the --skip-show-database option, you
cannot use this statement at all unless you have the SHOW DATABASES
privilege.
MySQL implements databases as directories in the data directory, so
this statement simply lists directories in that location. However, the
output may include names of directories that do not correspond to
actual databases.
Database information is also available from the INFORMATION_SCHEMA
SCHEMATA table. See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-schemata-tab
le.html.
*Caution*:
Because a global privilege is considered a privilege for all databases,
any global privilege enables a user to see all database names with SHOW
DATABASES or by examining the INFORMATION_SCHEMA SCHEMATA table.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-databases.html
https://dev.mysql.com/doc/refman/5.7/en/show-databases.html; ��@ l "� 6"2SHOW SCHEMAS Syntax:
SHOW {DATABASES | SCHEMAS}
[LIKE 'pattern' | WHERE expr]
SHOW DATABASES lists the databases on the MySQL server host. SHOW
SCHEMAS is a synonym for SHOW DATABASES. The LIKE clause, if present,
indicates which database names to match. The WHERE clause can be given
to select rows using more general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
You see only those databases for which you have some kind of privilege,
unless you have the global SHOW DATABASES privilege. You can also get
this list using the mysqlshow command.
If the server was started with the --skip-show-database option, you
cannot use this statement at all unless you have the SHOW DATABASES
privilege.
MySQL implements databases as directories in the data directory, so
this statement simply lists directories in that location. However, the
output may include names of directories that do not correspond to
actual databases.
Database information is also available from the INFORMATION_SCHEMA
SCHEMATA table. See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-schemata-tab
le.html.
*Caution*:
Because a global privilege is considered a privilege for all databases,
any global privilege enables a user to see all database names with SHOW
DATABASES or by examining the INFORMATION_SCHEMA SCHEMATA table.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-databases.html
https://dev.mysql.com/doc/refman/5.7/en/show-databases.html8 �@ � m "� 6"?SHOW ENGINE Z & %.https://dev.mysql.com/doc/refman/5.7/en/show-engine.html9 ܁@ (r n "� 6"LSHOW ENGINES Syntax:
SHOW [STORAGE] ENGINES
SHOW ENGINES displays status information about the server's storage
engines. This is particularly useful for checking whether a storage
engine is supported, or to see what the default engine is.
For information about MySQL storage engines, see
https://dev.mysql.com/doc/refman/5.7/en/innodb-storage-engine.html, and
https://dev.mysql.com/doc/refman/5.7/en/storage-engines.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-engines.html
https://dev.mysql.com/doc/refman/5.7/en/show-engines.html8 ��@ 0K o "� 6"YSHOW ERRORS Syntax:
SHOW ERRORS [LIMIT [offset,] row_count]
SHOW COUNT(*) ERRORS
SHOW ERRORS is a diagnostic statement that is similar to SHOW WARNINGS,
except that it displays information only for errors, rather than for
errors, warnings, and notes.
The LIMIT clause has the same syntax as for the SELECT statement. See
https://dev.mysql.com/doc/refman/5.7/en/select.html.
The SHOW COUNT(*) ERRORS statement displays the number of errors. You
can also retrieve this number from the error_count variable:
SHOW COUNT(*) ERRORS;
SELECT @@error_count;
SHOW ERRORS and error_count apply only to errors, not warnings or
notes. In other respects, they are similar to SHOW WARNINGS and
warning_count. In particular, SHOW ERRORS cannot display information
for more than max_error_count messages, and error_count can exceed the
value of max_error_count if the number of errors exceeds
max_error_count.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-errors.html
https://dev.mysql.com/doc/refman/5.7/en/show-errors.html8 I�@ 8� p "� 6"fSHOW EVENTS Syntax:
SHOW EVENTS
[{FROM | IN} schema_name]
[LIKE 'pattern' | WHERE expr]
This statement displays information about Event Manager events, which
are discussed in
https://dev.mysql.com/doc/refman/5.7/en/event-scheduler.html. It
requires the EVENT privilege for the database from which the events are
to be shown.
In its simplest form, SHOW EVENTS lists all of the events in the
current schema:
mysql> SELECT CURRENT_USER(), SCHEMA();
+----------------+----------+
| CURRENT_USER() | SCHEMA() |
+----------------+----------+
| jon@ghidora | myschema |
+----------------+----------+
1 row in set (0.00 sec)
mysql> SHOW EVENTS\G
*************************** 1. row ***************************
Db: myschema
Name: e_daily
Definer: jon@ghidora
Time zone: SYSTEM
Type: RECURRING
Execute at: NULL
Interval value: 1
Interval field: DAY
Starts: 2018-08-08 11:06:34
Ends: NULL
Status: ENABLED
Originator: 1
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
To see events for a specific schema, use the FROM clause. For example,
to see events for the test schema, use the following statement:
SHOW EVENTS FROM test;
The LIKE clause, if present, indicates which event names to match. The
WHERE clause can be given to select rows using more general conditions,
as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-events.html
https://dev.mysql.com/doc/refman/5.7/en/show-events.html? @ @t q "� 6"sSHOW FUNCTION CODE Syntax:
SHOW FUNCTION CODE func_name
This statement is similar to SHOW PROCEDURE CODE but for stored
functions. See [HELP SHOW PROCEDURE CODE].
URL: https://dev.mysql.com/doc/refman/5.7/en/show-function-code.html
https://dev.mysql.com/doc/refman/5.7/en/show-function-code.htmlA ��@ H� r "� 6"�SHOW FUNCTION STATUS Syntax:
SHOW FUNCTION STATUS
[LIKE 'pattern' | WHERE expr]
This statement is similar to SHOW PROCEDURE STATUS but for stored
functions. See [HELP SHOW PROCEDURE STATUS].
URL: https://dev.mysql.com/doc/refman/5.7/en/show-function-status.html
https://dev.mysql.com/doc/refman/5.7/en/show-function-status.html8 p�@ P s "� 6"�SHOW GRANTS Syntax:
SHOW GRANTS [FOR user]
This statement displays the privileges that are assigned to a MySQL
user account, in the form of GRANT statements that must be executed to
duplicate the privilege assignments.
*Note*:
To display nonprivilege information for MySQL accounts, use the SHOW
CREATE USER statement. See [HELP SHOW CREATE USER].
SHOW GRANTS requires the SELECT privilege for the mysql system
database, except to display privileges for the current user.
To name the account for SHOW GRANTS, use the same format as for the
GRANT statement (for example, 'jeffrey'@'localhost'):
mysql> SHOW GRANTS FOR 'jeffrey'@'localhost';
+------------------------------------------------------------------+
| Grants for jeffrey@localhost |
+------------------------------------------------------------------+
| GRANT USAGE ON *.* TO `jeffrey`@`localhost` |
| GRANT SELECT, INSERT, UPDATE ON `db1`.* TO `jeffrey`@`localhost` |
+------------------------------------------------------------------+
The host part, if omitted, defaults to '%'. For additional information
about specifying account names, see
https://dev.mysql.com/doc/refman/5.7/en/account-names.html.
To display the privileges granted to the current user (the account you
are using to connect to the server), you can use any of the following
statements:
SHOW GRANTS;
SHOW GRANTS FOR CURRENT_USER;
SHOW GRANTS FOR CURRENT_USER();
If SHOW GRANTS FOR CURRENT_USER (or any equivalent syntax) is used in
definer context, such as within a stored procedure that executes with
definer rather than invoker privileges, the grants displayed are those
of the definer and not the invoker.
SHOW GRANTS does not display privileges that are available to the named
account but are granted to a different account. For example, if an
anonymous account exists, the named account might be able to use its
privileges, but SHOW GRANTS does not display them.
SHOW GRANTS output does not include IDENTIFIED BY PASSWORD clauses. Use
the SHOW CREATE USER statement instead. See [HELP SHOW CREATE USER].
URL: https://dev.mysql.com/doc/refman/5.7/en/show-grants.html
https://dev.mysql.com/doc/refman/5.7/en/show-grants.html7 5�@ X� t "� 6"�SHOW INDEX Syntax:
SHOW {INDEX | INDEXES | KEYS}
{FROM | IN} tbl_name
[{FROM | IN} db_name]
[WHERE expr]
SHOW INDEX returns table index information. The format resembles that
of the SQLStatistics call in ODBC. This statement requires some
privilege for any column in the table.
mysql> SHOW INDEX FROM City\G
*************************** 1. row ***************************
Table: city
Non_unique: 0
Key_name: PRIMARY
Seq_in_index: 1
Column_name: ID
Collation: A
Cardinality: 4188
Sub_part: NULL
Packed: NULL
Null:
Index_type: BTREE
Comment:
Index_comment:
*************************** 2. row ***************************
Table: city
Non_unique: 1
Key_name: CountryCode
Seq_in_index: 1
Column_name: CountryCode
Collation: A
Cardinality: 232
Sub_part: NULL
Packed: NULL
Null:
Index_type: BTREE
Comment:
Index_comment:
An alternative to tbl_name FROM db_name syntax is db_name.tbl_name.
These two statements are equivalent:
SHOW INDEX FROM mytable FROM mydb;
SHOW INDEX FROM mydb.mytable;
The WHERE clause can be given to select rows using more general
conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
SHOW INDEX returns the following fields:
o Table
The name of the table.
o Non_unique
0 if the index cannot contain duplicates, 1 if it can.
o Key_name
The name of the index. If the index is the primary key, the name is
always PRIMARY.
o Seq_in_index
The column sequence number in the index, starting with 1.
o Column_name
The name of the column.
o Collation
How the column is sorted in the index. This can have values A
(ascending) or NULL (not sorted).
o Cardinality
An estimate of the number of unique values in the index. To update
this number, run ANALYZE TABLE or (for MyISAM tables) myisamchk -a.
Cardinality is counted based on statistics stored as integers, so the
value is not necessarily exact even for small tables. The higher the
cardinality, the greater the chance that MySQL uses the index when
doing joins.
o Sub_part
The index prefix. That is, the number of indexed characters if the
column is only partly indexed, NULL if the entire column is indexed.
*Note*:
Prefix limits are measured in bytes. However, prefix lengths for
index specifications in CREATE TABLE, ALTER TABLE, and CREATE INDEX
statements are interpreted as number of characters for nonbinary
string types (CHAR, VARCHAR, TEXT) and number of bytes for binary
string types (BINARY, VARBINARY, BLOB). Take this into account when
specifying a prefix length for a nonbinary string column that uses a
multibyte character set.
For additional information about index prefixes, see
https://dev.mysql.com/doc/refman/5.7/en/column-indexes.html, and
[HELP CREATE INDEX].
o Packed
Indicates how the key is packed. NULL if it is not.
o Null
Contains YES if the column may contain NULL values and '' if not.
o Index_type
The index method used (BTREE, FULLTEXT, HASH, RTREE).
o Comment
Information about the index not described in its own column, such as
disabled if the index is disabled.
o Index_comment
Any comment provided for the index with a COMMENT attribute when the
index was created.
Information about table indexes is also available from the
INFORMATION_SCHEMA STATISTICS table. See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-statistics-t
able.html.
You can list a table's indexes with the mysqlshow -k db_name tbl_name
command.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-index.html
https://dev.mysql.com/doc/refman/5.7/en/show-index.html? &�@ `� u "� 6"�SHOW MASTER STATUS Syntax:
SHOW MASTER STATUS
This statement provides status information about the binary log files
of the source. It requires either the SUPER or REPLICATION CLIENT
privilege.
Example:
mysql> SHOW MASTER STATUS\G
*************************** 1. row ***************************
File: source-bin.000002
Position: 1307
Binlog_Do_DB: test
Binlog_Ignore_DB: manual, mysql
Executed_Gtid_Set: 3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5
1 row in set (0.00 sec)
URL: https://dev.mysql.com/doc/refman/5.7/en/show-master-status.html
https://dev.mysql.com/doc/refman/5.7/en/show-master-status.html= r�@ h�� v "� 6"�SHOW OPEN TABLES Syntax:
SHOW OPEN TABLES
[{FROM | IN} db_name]
[LIKE 'pattern' | WHERE expr]
SHOW OPEN TABLES lists the non-TEMPORARY tables that are currently open
in the table cache. See
https://dev.mysql.com/doc/refman/5.7/en/table-cache.html. The FROM
clause, if present, restricts the tables shown to those present in the
db_name database. The LIKE clause, if present, indicates which table
names to match. The WHERE clause can be given to select rows using more
general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-open-tables.html
https://dev.mysql.com/doc/refman/5.7/en/show-open-tables.html p p
a c^��� #SqN:C Z "�o
%.����Syntax:
SHOW ENGINE engine_name {STATUS | MUTEX}
SHOW ENGINE displays operational information about a storage engine. It
requires the PROCESS privilege. The statement has these variants:
SHOW ENGINE INNODB STATUS
SHOW ENGINE INNODB MUTEX
SHOW ENGINE PERFORMANCE_SCHEMA STATUS
SHOW ENGINE INNODB STATUS displays extensive information from the
standard InnoDB Monitor about the state of the InnoDB storage engine.
For information about the standard monitor and other InnoDB Monitors
that provide information about InnoDB processing, see
https://dev.mysql.com/doc/refman/5.7/en/innodb-monitors.html.
SHOW ENGINE INNODB MUTEX displays InnoDB mutex and rw-lock statistics.
*Note*:
InnoDB mutexes and rwlocks can also be monitored using Performance
Schema tables. See
https://dev.mysql.com/doc/refman/5.7/en/monitor-innodb-mutex-waits-perf
ormance-schema.html.
SHOW ENGINE INNODB MUTEX output was removed in MySQL 5.7.2. It was
revised and reintroduced in MySQL 5.7.8.
In MySQL 5.7.8, mutex statistics collection is configured dynamically
using the following options:
o To enable the collection of mutex statistics, run:
SET GLOBAL innodb_monitor_enable='latch';
o To reset mutex statistics, run:
SET GLOBAL innodb_monitor_reset='latch';
o To disable the collection of mutex statistics, run:
SET GLOBAL innodb_monitor_disable='latch';
Collection of mutex statistics for SHOW ENGINE INNODB MUTEX can also be
enabled by setting innodb_monitor_enable='all', or disabled by setting
innodb_monitor_disable='all'.
SHOW ENGINE INNODB MUTEX output has these columns:
o Type
Always InnoDB.
o Name
Prior to MySQL 5.7.8, the Name field reports the source file where
the mutex is implemented, and the line number in the file where the
mutex is created. The line number is specific to your version of
MySQL. As of MySQL 5.7.8, only the mutex name is reported. File name
and line number are still reported for rwlocks.
o Status
The mutex status.
Prior to MySQL 5.7.8, the Status field displays several values if
WITH_DEBUG was defined at MySQL compilation time. If WITH_DEBUG was
not defined, the statement displays only the os_waits value. In the
latter case (without WITH_DEBUG), the information on which the output
is based is insufficient to distinguish regular mutexes and mutexes
that protect rwlocks (which permit multiple readers or a single
writer). Consequently, the output may appear to contain multiple rows
for the same mutex. Pre-MySQL 5.7.8 Status field values include:
o count indicates how many times the mutex was requested.
o spin_waits indicates how many times the spinlock had to run.
o spin_rounds indicates the number of spinlock rounds. (spin_rounds
divided by spin_waits provides the average round count.)
o os_waits indicates the number of operating system waits. This
occurs when the spinlock did not work (the mutex was not locked
during the spinlock and it was necessary to yield to the operating
system and wait).
o os_yields indicates the number of times a thread trying to lock a
mutex gave up its timeslice and yielded to the operating system (on
the presumption that permitting other threads to run frees the
mutex so that it can be locked).
o os_wait_times indicates the amount of time (in ms) spent in
operating system waits. In MySQL 5.7 timing is disabled and this
value is always 0.
As of MySQL 5.7.8, the Status field reports the number of spins,
waits, and calls. Statistics for low-level operating system mutexes,
which are implemented outside of InnoDB, are not reported.
o spins indicates the number of spins.
o waits indicates the number of mutex waits.
o calls indicates how many times the mutex was requested.
SHOW ENGINE INNODB MUTEX does not list mutexes and rw-locks for each
buffer pool block, as the amount of output would be overwhelming on
systems with a large buffer pool. SHOW ENGINE INNODB MUTEX does,
however, print aggregate BUF_BLOCK_MUTEX spin, wait, and call values
for buffer pool block mutexes and rw-locks. SHOW ENGINE INNODB MUTEX
also does not list any mutexes or rw-locks that have never been waited
on (os_waits=0). Thus, SHOW ENGINE INNODB MUTEX only displays
information about mutexes and rw-locks outside of the buffer pool that
have caused at least one OS-level wait.
Use SHOW ENGINE PERFORMANCE_SCHEMA STATUS to inspect the internal
operation of the Performance Schema code:
mysql> SHOW ENGINE PERFORMANCE_SCHEMA STATUS\G
...
*************************** 3. row ***************************
Type: performance_schema
Name: events_waits_history.size
Status: 76
*************************** 4. row ***************************
Type: performance_schema
Name: events_waits_history.count
Status: 10000
*************************** 5. row ***************************
Type: performance_schema
Name: events_waits_history.memory
Status: 760000
...
*************************** 57. row ***************************
Type: performance_schema
Name: performance_schema.memory
Status: 26459600
...
This statement is intended to help the DBA understand the effects that
different Performance Schema options have on memory requirements.
Name values consist of two parts, which name an internal buffer and a
buffer attribute, respectively. Interpret buffer names as follows:
o An internal buffer that is not exposed as a table is named within
parentheses. Examples: (pfs_cond_class).size,
(pfs_mutex_class).memory.
o An internal buffer that is exposed as a table in the
performance_schema database is named after the table, without
parentheses. Examples: events_waits_history.size,
mutex_instances.count.
o A value that applies to the Performance Schema as a whole begins with
performance_schema. Example: performance_schema.memory.
Buffer attributes have these meanings:
o size is the size of the internal record used by the implementation,
such as the size of a row in a table. size values cannot be changed.
o count is the number of internal records, such as the number of rows
in a table. count values can be changed using Performance Schema
configuration options.
o For a table, tbl_name.memory is the product of size and count. For
the Performance Schema as a whole, performance_schema.memory is the
sum of all the memory used (the sum of all other memory values).
In some cases, there is a direct relationship between a Performance
Schema configuration parameter and a SHOW ENGINE value. For example,
events_waits_history_long.count corresponds to
performance_schema_events_waits_history_long_size. In other cases, the
relationship is more complex. For example, events_waits_history.count
corresponds to performance_schema_events_waits_history_size (the number
of rows per thread) multiplied by
performance_schema_max_thread_instances ( the number of threads).
SHOW ENGINE NDB STATUS If the server has the NDB storage engine
enabled, SHOW ENGINE NDB STATUS displays cluster status information
such as the number of connected data nodes, the cluster connectstring,
and cluster binary log epochs, as well as counts of various Cluster API
objects created by the MySQL Server when connected to the cluster.
Sample output from this statement is shown here:
mysql> SHOW ENGINE NDB STATUS;
+------------+-----------------------+--------------------------------------------------+
| Type | Name | Status |
+------------+-----------------------+--------------------------------------------------+
| ndbcluster | connection | cluster_node_id=7,
connected_host=198.51.100.103, connected_port=1186, number_of_data_nodes=4,
number_of_ready_data_nodes=3, connect_count=0 |
| ndbcluster | NdbTransaction | created=6, free=0, sizeof=212 |
| ndbcluster | NdbOperation | created=8, free=8, sizeof=660 |
| ndbcluster | NdbIndexScanOperation | created=1, free=1, sizeof=744 |
| ndbcluster | NdbIndexOperation | created=0, free=0, sizeof=664 |
| ndbcluster | NdbRecAttr | created=1285, free=1285, sizeof=60 |
| ndbcluster | NdbApiSignal | created=16, free=16, sizeof=136 |
| ndbcluster | NdbLabel | created=0, free=0, sizeof=196 |
| ndbcluster | NdbBranch | created=0, free=0, sizeof=24 |
| ndbcluster | NdbSubroutine | created=0, free=0, sizeof=68 |
| ndbcluster | NdbCall | created=0, free=0, sizeof=16 |
| ndbcluster | NdbBlob | created=1, free=1, sizeof=264 |
| ndbcluster | NdbReceiver | created=4, free=0, sizeof=68 |
| ndbcluster | binlog | latest_epoch=155467, latest_trans_epoch=148126,
latest_received_binlog_epoch=0, latest_handled_binlog_epoch=0,
latest_applied_binlog_epoch=0 |
+------------+-----------------------+--------------------------------------------------+
The Status column in each of these rows provides information about the
MySQL server's connection to the cluster and about the cluster binary
log's status, respectively. The Status information is in the form of
comma-delimited set of name/value pairs.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-engine.html
N:C "�o�FV [ Y \ #��E� 4u�
2 infimum supremum9 �@ � w "� 6"�SHOW PLUGINS Syntax:
SHOW PLUGINS
SHOW PLUGINS displays information about server plugins.
Example of SHOW PLUGINS output:
mysql> SHOW PLUGINS\G
*************************** 1. row ***************************
Name: binlog
Status: ACTIVE
Type: STORAGE ENGINE
Library: NULL
License: GPL
*************************** 2. row ***************************
Name: CSV
Status: ACTIVE
Type: STORAGE ENGINE
Library: NULL
License: GPL
*************************** 3. row ***************************
Name: MEMORY
Status: ACTIVE
Type: STORAGE ENGINE
Library: NULL
License: GPL
*************************** 4. row ***************************
Name: MyISAM
Status: ACTIVE
Type: STORAGE ENGINE
Library: NULL
License: GPL
...
URL: https://dev.mysql.com/doc/refman/5.7/en/show-plugins.html
https://dev.mysql.com/doc/refman/5.7/en/show-plugins.html< ��@ � x "� 6"�SHOW PRIVILEGES Syntax:
SHOW PRIVILEGES
SHOW PRIVILEGES shows the list of system privileges that the MySQL
server supports. The exact list of privileges depends on the version of
your server.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-privileges.html
https://dev.mysql.com/doc/refman/5.7/en/show-privileges.html@����@ � y "� 6"�SHOW PROCEDURE CODE Syntax:
SHOW PROCEDURE CODE proc_name
This statement is a MySQL extension that is available only for servers
that have been built with debugging support. It displays a
representation of the internal implementation of the named stored
procedure. A similar statement, SHOW FUNCTION CODE, displays
information about stored functions (see [HELP SHOW FUNCTION CODE]).
To use either statement, you must be the owner of the routine or have
SELECT access to the mysql.proc table.
If the named routine is available, each statement produces a result
set. Each row in the result set corresponds to one "instruction" in the
routine. The first column is Pos, which is an ordinal number beginning
with 0. The second column is Instruction, which contains an SQL
statement (usually changed from the original source), or a directive
which has meaning only to the stored-routine handler.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-procedure-code.html
mysql> DELIMITER //
mysql> CREATE PROCEDURE p1 ()
BEGIN
DECLARE fanta INT DEFAULT 55;
DROP TABLE t2;
LOOP
INSERT INTO t3 VALUES (fanta);
END LOOP;
END//
Query OK, 0 rows affected (0.01 sec)
mysql> SHOW PROCEDURE CODE p1//
+-----+----------------------------------------+
| Pos | Instruction |
+-----+----------------------------------------+
| 0 | set fanta@0 55 |
| 1 | stmt 9 "DROP TABLE t2" |
| 2 | stmt 5 "INSERT INTO t3 VALUES (fanta)" |
| 3 | jump 2 |
+-----+----------------------------------------+
4 rows in set (0.00 sec)
mysql> CREATE FUNCTION test.hello (s CHAR(20))
RETURNS CHAR(50) DETERMINISTIC
RETURN CONCAT('Hello, ',s,'!');
Query OK, 0 rows affected (0.00 sec)
mysql> SHOW FUNCTION CODE test.hello;
+-----+---------------------------------------+
| Pos | Instruction |
+-----+---------------------------------------+
| 0 | freturn 254 concat('Hello, ',s@0,'!') |
+-----+---------------------------------------+
1 row in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/show-procedure-code.htmlB��!�@ (s z "� 6"�SHOW PROCEDURE STATUS Syntax:
SHOW PROCEDURE STATUS
[LIKE 'pattern' | WHERE expr]
This statement is a MySQL extension. It returns characteristics of a
stored procedure, such as the database, name, type, creator, creation
and modification dates, and character set information. A similar
statement, SHOW FUNCTION STATUS, displays information about stored
functions (see [HELP SHOW FUNCTION STATUS]).
To use either statement, you must be the owner of the routine or have
SELECT access to the mysql.proc table.
The LIKE clause, if present, indicates which procedure or function
names to match. The WHERE clause can be given to select rows using more
general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-procedure-status.html
mysql> SHOW PROCEDURE STATUS LIKE 'sp1'\G
*************************** 1. row ***************************
Db: test
Name: sp1
Type: PROCEDURE
Definer: testuser@localhost
Modified: 2018-08-08 13:54:11
Created: 2018-08-08 13:54:11
Security_type: DEFINER
Comment:
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
mysql> SHOW FUNCTION STATUS LIKE 'hello'\G
*************************** 1. row ***************************
Db: test
Name: hello
Type: FUNCTION
Definer: testuser@localhost
Modified: 2020-03-10 11:09:33
Created: 2020-03-10 11:09:33
Security_type: DEFINER
Comment:
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
https://dev.mysql.com/doc/refman/5.7/en/show-procedure-status.html= _�@ 0� { "� 6"�SHOW PROCESSLIST Syntax:
SHOW [FULL] PROCESSLIST
The MySQL process list indicates the operations currently being
performed by the set of threads executing within the server. The SHOW
PROCESSLIST statement is one source of process information. For a
comparison of this statement with other sources, see
https://dev.mysql.com/doc/refman/5.7/en/processlist-access.html#process
list-sources.
If you have the PROCESS privilege, you can see all threads, even those
belonging to other users. Otherwise (without the PROCESS privilege),
nonanonymous users have access to information about their own threads
but not threads for other users, and anonymous users have no access to
thread information.
Without the FULL keyword, SHOW PROCESSLIST displays only the first 100
characters of each statement in the Info field.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-processlist.html
https://dev.mysql.com/doc/refman/5.7/en/show-processlist.html9Ɉ�@ 8G | "� 6#SHOW PROFILE Syntax:
SHOW PROFILE [type [, type] ... ]
[FOR QUERY n]
[LIMIT row_count [OFFSET offset]]
type: {
ALL
| BLOCK IO
| CONTEXT SWITCHES
| CPU
| IPC
| MEMORY
| PAGE FAULTS
| SOURCE
| SWAPS
}
The SHOW PROFILE and SHOW PROFILES statements display profiling
information that indicates resource usage for statements executed
during the course of the current session.
*Note*:
The SHOW PROFILE and SHOW PROFILES statements are deprecated; expect
them to be removed in a future MySQL release. Use the Performance
Schema instead; see
https://dev.mysql.com/doc/refman/5.7/en/performance-schema-query-profil
ing.html.
To control profiling, use the profiling session variable, which has a
default value of 0 (OFF). Enable profiling by setting profiling to 1 or
ON:
mysql> SET profiling = 1;
SHOW PROFILES displays a list of the most recent statements sent to the
server. The size of the list is controlled by the
profiling_history_size session variable, which has a default value of
15. The maximum value is 100. Setting the value to 0 has the practical
effect of disabling profiling.
All statements are profiled except SHOW PROFILE and SHOW PROFILES, so
neither of those statements appears in the profile list. Malformed
statements are profiled. For example, SHOW PROFILING is an illegal
statement, and a syntax error occurs if you try to execute it, but it
shows up in the profiling list.
SHOW PROFILE displays detailed information about a single statement.
Without the FOR QUERY n clause, the output pertains to the most
recently executed statement. If FOR QUERY n is included, SHOW PROFILE
displays information for statement n. The values of n correspond to the
Query_ID values displayed by SHOW PROFILES.
The LIMIT row_count clause may be given to limit the output to
row_count rows. If LIMIT is given, OFFSET offset may be added to begin
the output offset rows into the full set of rows.
By default, SHOW PROFILE displays Status and Duration columns. The
Status values are like the State values displayed by SHOW PROCESSLIST,
although there might be some minor differences in interpretion for the
two statements for some status values (see
https://dev.mysql.com/doc/refman/5.7/en/thread-information.html).
Optional type values may be specified to display specific additional
types of information:
o ALL displays all information
o BLOCK IO displays counts for block input and output operations
o CONTEXT SWITCHES displays counts for voluntary and involuntary
context switches
o CPU displays user and system CPU usage times
o IPC displays counts for messages sent and received
o MEMORY is not currently implemented
o PAGE FAULTS displays counts for major and minor page faults
o SOURCE displays the names of functions from the source code, together
with the name and line number of the file in which the function
occurs
o SWAPS displays swap counts
Profiling is enabled per session. When a session ends, its profiling
information is lost.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-profile.html
mysql> SELECT @@profiling;
+-------------+
| @@profiling |
+-------------+
| 0 |
+-------------+
1 row in set (0.00 sec)
mysql> SET profiling = 1;
Query OK, 0 rows affected (0.00 sec)
mysql> DROP TABLE IF EXISTS t1;
Query OK, 0 rows affected, 1 warning (0.00 sec)
mysql> CREATE TABLE T1 (id INT);
Query OK, 0 rows affected (0.01 sec)
mysql> SHOW PROFILES;
+----------+----------+--------------------------+
| Query_ID | Duration | Query |
+----------+----------+--------------------------+
| 0 | 0.000088 | SET PROFILING = 1 |
| 1 | 0.000136 | DROP TABLE IF EXISTS t1 |
| 2 | 0.011947 | CREATE TABLE t1 (id INT) |
+----------+----------+--------------------------+
3 rows in set (0.00 sec)
mysql> SHOW PROFILE;
+----------------------+----------+
| Status | Duration |
+----------------------+----------+
| checking permissions | 0.000040 |
| creating table | 0.000056 |
| After create | 0.011363 |
| query end | 0.000375 |
| freeing items | 0.000089 |
| logging slow query | 0.000019 |
| cleaning up | 0.000005 |
+----------------------+----------+
7 rows in set (0.00 sec)
mysql> SHOW PROFILE FOR QUERY 1;
+--------------------+----------+
| Status | Duration |
+--------------------+----------+
| query end | 0.000107 |
| freeing items | 0.000008 |
| logging slow query | 0.000015 |
| cleaning up | 0.000006 |
+--------------------+----------+
4 rows in set (0.00 sec)
mysql> SHOW PROFILE CPU FOR QUERY 2;
+----------------------+----------+----------+------------+
| Status | Duration | CPU_user | CPU_system |
+----------------------+----------+----------+------------+
| checking permissions | 0.000040 | 0.000038 | 0.000002 |
| creating table | 0.000056 | 0.000028 | 0.000028 |
| After create | 0.011363 | 0.000217 | 0.001571 |
| query end | 0.000375 | 0.000013 | 0.000028 |
| freeing items | 0.000089 | 0.000010 | 0.000014 |
| logging slow query | 0.000019 | 0.000009 | 0.000010 |
| cleaning up | 0.000005 | 0.000003 | 0.000002 |
+----------------------+----------+----------+------------+
7 rows in set (0.00 sec)
https://dev.mysql.com/doc/refman/5.7/en/show-profile.html: 7�@ @� } "� 6#SHOW PROFILES Syntax:
SHOW PROFILES
The SHOW PROFILES statement, together with SHOW PROFILE, displays
profiling information that indicates resource usage for statements
executed during the course of the current session. For more
information, see [HELP SHOW PROFILE].
*Note*:
The SHOW PROFILE and SHOW PROFILES statements are deprecated; expect
them to be removed in a future MySQL release. Use the Performance
Schema instead; see
https://dev.mysql.com/doc/refman/5.7/en/performance-schema-query-profil
ing.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-profiles.html
https://dev.mysql.com/doc/refman/5.7/en/show-profiles.htmlA ǁ@ H�V ~ "� 6# SHOW RELAYLOG EVENTS Syntax:
SHOW RELAYLOG EVENTS
[IN 'log_name']
[FROM pos]
[LIMIT [offset,] row_count]
[channel_option]
channel_option:
FOR CHANNEL channel
Shows the events in the relay log of a replica. If you do not specify
'log_name', the first relay log is displayed. This statement has no
effect on the source. SHOW RELAYLOG EVENTS requires the REPLICATION
SLAVE privilege.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-relaylog-events.html
https://dev.mysql.com/doc/refman/5.7/en/show-relaylog-events.html p� c�FV #��ְ�# \ [ ] #��E� /l� ) infimum supremum= U�@ � "� 6#)SHOW SLAVE HOSTS Syntax:
SHOW SLAVE HOSTS
Displays a list of replicas currently registered with the source.
SHOW SLAVE HOSTS should be executed on a server that acts as a
replication source. SHOW SLAVE HOSTS requires the REPLICATION SLAVE
privilege. The statement displays information about servers that are or
have been connected as replicas, with each row of the result
corresponding to one replica server, as shown here:
mysql> SHOW SLAVE HOSTS;
+------------+-----------+------+-----------+--------------------------------------+
| Server_id | Host | Port | Master_id | Slave_UUID |
+------------+-----------+------+-----------+--------------------------------------+
| 192168010 | iconnect2 | 3306 | 192168011 | 14cb6624-7f93-11e0-b2c0-c80aa9429562 |
| 1921680101 | athena | 3306 | 192168011 | 07af4990-f41f-11df-a566-7ac56fdaf645 |
+------------+-----------+------+-----------+--------------------------------------+
o Server_id: The unique server ID of the replica server, as configured
in the replica server's option file, or on the command line with
--server-id=value.
o Host: The host name of the replica server as specified on the replica
with the --report-host option. This can differ from the machine name
as configured in the operating system.
o User: The replica server user name as, specified on the replica with
the --report-user option. Statement output includes this column only
if the source server is started with the --show-slave-auth-info
option.
o Password: The replica server password as, specified on the replica
with the --report-password option. Statement output includes this
column only if the source server is started with the
--show-slave-auth-info option.
o Port: The port on the source to which the replica server is
listening, as specified on the replica with the --report-port option.
A zero in this column means that the replica port (--report-port) was
not set.
o Master_id: The unique server ID of the source server that the replica
server is replicating from. This is the server ID of the server on
which SHOW SLAVE HOSTS is executed, so this same value is listed for
each row in the result.
o Slave_UUID: The globally unique ID of this replica, as generated on
the replica and found in the replica's auto.cnf file.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-slave-hosts.html
https://dev.mysql.com/doc/refman/5.7/en/show-slave-hosts.html> ��@ & � "� 6#6SHOW SLAVE STATUS Syntax:
SHOW SLAVE STATUS [FOR CHANNEL channel]
This statement provides status information on essential parameters of
the replica threads. It requires either the SUPER or REPLICATION CLIENT
privilege.
If you issue this statement using the mysql client, you can use a \G
statement terminator rather than a semicolon to obtain a more readable
vertical layout:
mysql> SHOW SLAVE STATUS\G
*************************** 1. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: localhost
Master_User: repl
Master_Port: 13000
Connect_Retry: 60
Master_Log_File: source-bin.000002
Read_Master_Log_Pos: 1307
Relay_Log_File: replica-relay-bin.000003
Relay_Log_Pos: 1508
Relay_Master_Log_File: source-bin.000002
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 1307
Relay_Log_Space: 1858
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Master_Server_Id: 1
Master_UUID: 3e11fa47-71ca-11e1-9e33-c80aa9429562
Master_Info_File: /var/mysqld.2/data/master.info
SQL_Delay: 0
SQL_Remaining_Delay: NULL
Slave_SQL_Running_State: Reading event from the relay log
Master_Retry_Count: 10
Master_Bind:
Last_IO_Error_Timestamp:
Last_SQL_Error_Timestamp:
Master_SSL_Crl:
Master_SSL_Crlpath:
Retrieved_Gtid_Set: 3e11fa47-71ca-11e1-9e33-c80aa9429562:1-5
Executed_Gtid_Set: 3e11fa47-71ca-11e1-9e33-c80aa9429562:1-5
Auto_Position: 1
Replicate_Rewrite_DB:
Channel_name:
Master_TLS_Version: TLSv1.2
The Performance Schema provides tables that expose replication
information. This is similar to the information available from the SHOW
SLAVE STATUS statement, but represented in table form. For details, see
https://dev.mysql.com/doc/refman/5.7/en/performance-schema-replication-
tables.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-slave-status.html
https://dev.mysql.com/doc/refman/5.7/en/show-slave-status.html8 ��@ ; � "� 6#CSHOW STATUS Syntax:
SHOW [GLOBAL | SESSION] STATUS
[LIKE 'pattern' | WHERE expr]
*Note*:
The value of the show_compatibility_56 system variable affects the
information available from and privileges required for the statement
described here. For details, see the description of that variable in
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
SHOW STATUS provides server status information (see
https://dev.mysql.com/doc/refman/5.7/en/server-status-variables.html).
This statement does not require any privilege. It requires only the
ability to connect to the server.
Status variable information is also available from these sources:
o Performance Schema tables. See
https://dev.mysql.com/doc/refman/5.7/en/performance-schema-status-var
iable-tables.html.
o The GLOBAL_STATUS and SESSION_STATUS tables. See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-status-tab
le.html.
o The mysqladmin extended-status command. See
https://dev.mysql.com/doc/refman/5.7/en/mysqladmin.html.
For SHOW STATUS, a LIKE clause, if present, indicates which variable
names to match. A WHERE clause can be given to select rows using more
general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
SHOW STATUS accepts an optional GLOBAL or SESSION variable scope
modifier:
o With a GLOBAL modifier, the statement displays the global status
values. A global status variable may represent status for some aspect
of the server itself (for example, Aborted_connects), or the
aggregated status over all connections to MySQL (for example,
Bytes_received and Bytes_sent). If a variable has no global value,
the session value is displayed.
o With a SESSION modifier, the statement displays the status variable
values for the current connection. If a variable has no session
value, the global value is displayed. LOCAL is a synonym for SESSION.
o If no modifier is present, the default is SESSION.
The scope for each status variable is listed at
https://dev.mysql.com/doc/refman/5.7/en/server-status-variables.html.
Each invocation of the SHOW STATUS statement uses an internal temporary
table and increments the global Created_tmp_tables value.
With a LIKE clause, the statement displays only rows for those
variables with names that match the pattern:
mysql> SHOW STATUS LIKE 'Key%';
+--------------------+----------+
| Variable_name | Value |
+--------------------+----------+
| Key_blocks_used | 14955 |
| Key_read_requests | 96854827 |
| Key_reads | 162040 |
| Key_write_requests | 7589728 |
| Key_writes | 3813196 |
+--------------------+----------+
URL: https://dev.mysql.com/doc/refman/5.7/en/show-status.html
https://dev.mysql.com/doc/refman/5.7/en/show-status.html> .�@ (� � "� 6#PSHOW TABLE STATUS Syntax:
SHOW TABLE STATUS
[{FROM | IN} db_name]
[LIKE 'pattern' | WHERE expr]
SHOW TABLE STATUS works likes SHOW TABLES, but provides a lot of
information about each non-TEMPORARY table. You can also get this list
using the mysqlshow --status db_name command. The LIKE clause, if
present, indicates which table names to match. The WHERE clause can be
given to select rows using more general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-table-status.html
https://dev.mysql.com/doc/refman/5.7/en/show-table-status.html8 у@ 0f � "� 6#]SHOW TABLES Syntax:
SHOW [FULL] TABLES
[{FROM | IN} db_name]
[LIKE 'pattern' | WHERE expr]
SHOW TABLES lists the non-TEMPORARY tables in a given database. You can
also get this list using the mysqlshow db_name command. The LIKE
clause, if present, indicates which table names to match. The WHERE
clause can be given to select rows using more general conditions, as
discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
Matching performed by the LIKE clause is dependent on the setting of
the lower_case_table_names system variable.
This statement also lists any views in the database. The optional FULL
modifier causes SHOW TABLES to display a second output column with
values of BASE TABLE for a table, VIEW for a view, or SYSTEM VIEW for
an INFORMATION_SCHEMA table.
If you have no privileges for a base table or view, it does not show up
in the output from SHOW TABLES or mysqlshow db_name.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-tables.html
https://dev.mysql.com/doc/refman/5.7/en/show-tables.html: ޅ@ 8�o � "� 6#jSHOW TRIGGERS Syntax:
SHOW TRIGGERS
[{FROM | IN} db_name]
[LIKE 'pattern' | WHERE expr]
SHOW TRIGGERS lists the triggers currently defined for tables in a
database (the default database unless a FROM clause is given). This
statement returns results only for databases and tables for which you
have the TRIGGER privilege. The LIKE clause, if present, indicates
which table names (not trigger names) to match and causes the statement
to display triggers for those tables. The WHERE clause can be given to
select rows using more general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
For the ins_sum trigger defined in
https://dev.mysql.com/doc/refman/5.7/en/triggers.html, the output of
SHOW TRIGGERS is as shown here:
mysql> SHOW TRIGGERS LIKE 'acc%'\G
*************************** 1. row ***************************
Trigger: ins_sum
Event: INSERT
Table: account
Statement: SET @sum = @sum + NEW.amount
Timing: BEFORE
Created: 2018-08-08 10:10:12.61
sql_mode: ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,
NO_ZERO_IN_DATE,NO_ZERO_DATE,
ERROR_FOR_DIVISION_BY_ZERO,
NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
Definer: me@localhost
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
URL: https://dev.mysql.com/doc/refman/5.7/en/show-triggers.html
https://dev.mysql.com/doc/refman/5.7/en/show-triggers.html p cְ�# #�Ȗ2�l ] \ ^ #��E� 9� 7A infimum supremum; ��@
@ � "� 6#wSHOW VARIABLES Syntax:
SHOW [GLOBAL | SESSION] VARIABLES
[LIKE 'pattern' | WHERE expr]
*Note*:
The value of the show_compatibility_56 system variable affects the
information available from and privileges required for the statement
described here. For details, see the description of that variable in
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
SHOW VARIABLES shows the values of MySQL system variables (see
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html).
This statement does not require any privilege. It requires only the
ability to connect to the server.
System variable information is also available from these sources:
o Performance Schema tables. See
https://dev.mysql.com/doc/refman/5.7/en/performance-schema-system-var
iable-tables.html.
o The GLOBAL_VARIABLES and SESSION_VARIABLES tables. See
https://dev.mysql.com/doc/refman/5.7/en/information-schema-variables-
table.html.
o The mysqladmin variables command. See
https://dev.mysql.com/doc/refman/5.7/en/mysqladmin.html.
For SHOW VARIABLES, a LIKE clause, if present, indicates which variable
names to match. A WHERE clause can be given to select rows using more
general conditions, as discussed in
https://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
SHOW VARIABLES accepts an optional GLOBAL or SESSION variable scope
modifier:
o With a GLOBAL modifier, the statement displays global system variable
values. These are the values used to initialize the corresponding
session variables for new connections to MySQL. If a variable has no
global value, no value is displayed.
o With a SESSION modifier, the statement displays the system variable
values that are in effect for the current connection. If a variable
has no session value, the global value is displayed. LOCAL is a
synonym for SESSION.
o If no modifier is present, the default is SESSION.
The scope for each system variable is listed at
https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
SHOW VARIABLES is subject to a version-dependent display-width limit.
For variables with very long values that are not completely displayed,
use SELECT as a workaround. For example:
SELECT @@GLOBAL.innodb_data_file_path;
Most system variables can be set at server startup (read-only variables
such as version_comment are exceptions). Many can be changed at runtime
with the SET statement. See
https://dev.mysql.com/doc/refman/5.7/en/using-system-variables.html,
and [HELP SET].
With a LIKE clause, the statement displays only rows for those
variables with names that match the pattern. To obtain the row for a
specific variable, use a LIKE clause as shown:
SHOW VARIABLES LIKE 'max_join_size';
SHOW SESSION VARIABLES LIKE 'max_join_size';
To get a list of variables whose name match a pattern, use the %
wildcard character in a LIKE clause:
SHOW VARIABLES LIKE '%size%';
SHOW GLOBAL VARIABLES LIKE '%size%';
Wildcard characters can be used in any position within the pattern to
be matched. Strictly speaking, because _ is a wildcard that matches any
single character, you should escape it as \_ to match it literally. In
practice, this is rarely necessary.
URL: https://dev.mysql.com/doc/refman/5.7/en/show-variables.html
https://dev.mysql.com/doc/refman/5.7/en/show-variables.html: 1�@ � � "� 6#�SHOW WARNINGS Syntax:
SHOW WARNINGS [LIMIT [offset,] row_count]
SHOW COUNT(*) WARNINGS
SHOW WARNINGS is a diagnostic statement that displays information about
the conditions (errors, warnings, and notes) resulting from executing a
statement in the current session. Warnings are generated for DML
statements such as INSERT, UPDATE, and LOAD DATA as well as DDL
statements such as CREATE TABLE and ALTER TABLE.
The LIMIT clause has the same syntax as for the SELECT statement. See
https://dev.mysql.com/doc/refman/5.7/en/select.html.
SHOW WARNINGS is also used following EXPLAIN, to display the extended
information generated by EXPLAIN. See
https://dev.mysql.com/doc/refman/5.7/en/explain-extended.html.
SHOW WARNINGS displays information about the conditions resulting from
execution of the most recent nondiagnostic statement in the current
session. If the most recent statement resulted in an error during
parsing, SHOW WARNINGS shows the resulting conditions, regardless of
statement type (diagnostic or nondiagnostic).
The SHOW COUNT(*) WARNINGS diagnostic statement displays the total
number of errors, warnings, and notes. You can also retrieve this
number from the warning_count system variable:
SHOW COUNT(*) WARNINGS;
SELECT @@warning_count;
A difference in these statements is that the first is a diagnostic
statement that does not clear the message list. The second, because it
is a SELECT statement is considered nondiagnostic and does clear the
message list.
A related diagnostic statement, SHOW ERRORS, shows only error
conditions (it excludes warnings and notes), and SHOW COUNT(*) ERRORS
statement displays the total number of errors. See [HELP SHOW ERRORS].
GET DIAGNOSTICS can be used to examine information for individual
conditions. See [HELP GET DIAGNOSTICS].
URL: https://dev.mysql.com/doc/refman/5.7/en/show-warnings.html
https://dev.mysql.com/doc/refman/5.7/en/show-warnings.html3 ܁@ l � "� 6#�BINLOG Syntax:
BINLOG 'str'
BINLOG is an internal-use statement. It is generated by the mysqlbinlog
program as the printable representation of certain events in binary log
files. (See https://dev.mysql.com/doc/refman/5.7/en/mysqlbinlog.html.)
The 'str' value is a base 64-encoded string the that server decodes to
determine the data change indicated by the corresponding event. This
statement requires the SUPER privilege.
URL: https://dev.mysql.com/doc/refman/5.7/en/binlog.html
https://dev.mysql.com/doc/refman/5.7/en/binlog.html8 n�@ ( � "� 6#�CACHE INDEX Syntax:
CACHE INDEX {
tbl_index_list [, tbl_index_list] ...
| tbl_name PARTITION (partition_list)
}
IN key_cache_name
tbl_index_list:
tbl_name [{INDEX|KEY} (index_name[, index_name] ...)]
partition_list: {
partition_name[, partition_name] ...
| ALL
}
The CACHE INDEX statement assigns table indexes to a specific key
cache. It applies only to MyISAM tables, including partitioned MyISAM
tables. After the indexes have been assigned, they can be preloaded
into the cache if desired with LOAD INDEX INTO CACHE.
The following statement assigns indexes from the tables t1, t2, and t3
to the key cache named hot_cache:
mysql> CACHE INDEX t1, t2, t3 IN hot_cache;
+---------+--------------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+---------+--------------------+----------+----------+
| test.t1 | assign_to_keycache | status | OK |
| test.t2 | assign_to_keycache | status | OK |
| test.t3 | assign_to_keycache | status | OK |
+---------+--------------------+----------+----------+
URL: https://dev.mysql.com/doc/refman/5.7/en/cache-index.html
https://dev.mysql.com/doc/refman/5.7/en/cache-index.html2 �@ 0
� � "� 6#�FLUSH Syntax:
FLUSH [NO_WRITE_TO_BINLOG | LOCAL] {
flush_option [, flush_option] ...
| tables_option
}
flush_option: {
BINARY LOGS
| DES_KEY_FILE
| ENGINE LOGS
| ERROR LOGS
| GENERAL LOGS
| HOSTS
| LOGS
| PRIVILEGES
| OPTIMIZER_COSTS
| QUERY CACHE
| RELAY LOGS [FOR CHANNEL channel]
| SLOW LOGS
| STATUS
| USER_RESOURCES
}
tables_option: {
TABLES
| TABLES tbl_name [, tbl_name] ...
| TABLES WITH READ LOCK
| TABLES tbl_name [, tbl_name] ... WITH READ LOCK
| TABLES tbl_name [, tbl_name] ... FOR EXPORT
}
The FLUSH statement has several variant forms that clear or reload
various internal caches, flush tables, or acquire locks. To execute
FLUSH, you must have the RELOAD privilege. Specific flush options might
require additional privileges, as indicated in the option descriptions.
*Note*:
It is not possible to issue FLUSH statements within stored functions or
triggers. However, you may use FLUSH in stored procedures, so long as
these are not called from stored functions or triggers. See
https://dev.mysql.com/doc/refman/5.7/en/stored-program-restrictions.html
.
By default, the server writes FLUSH statements to the binary log so
that they replicate to replicas. To suppress logging, specify the
optional NO_WRITE_TO_BINLOG keyword or its alias LOCAL.
*Note*:
FLUSH LOGS, FLUSH BINARY LOGS, FLUSH TABLES WITH READ LOCK (with or
without a table list), and FLUSH TABLES tbl_name ... FOR EXPORT are not
written to the binary log in any case because they would cause problems
if replicated to a replica.
The FLUSH statement causes an implicit commit. See
https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
The mysqladmin utility provides a command-line interface to some flush
operations, using commands such as flush-hosts, flush-logs,
flush-privileges, flush-status, and flush-tables. See
https://dev.mysql.com/doc/refman/5.7/en/mysqladmin.html.
Sending a SIGHUP signal to the server causes several flush operations
to occur that are similar to various forms of the FLUSH statement.
Signals can be sent by the root system account or the system account
that owns the server process. This enables the flush operations to be
performed without having to connect to the server, which requires a
MySQL account that has privileges sufficient for those operations. See
https://dev.mysql.com/doc/refman/5.7/en/unix-signal-response.html.
The RESET statement is similar to FLUSH. See [HELP RESET], for
information about using RESET with replication.
URL: https://dev.mysql.com/doc/refman/5.7/en/flush.html
https://dev.mysql.com/doc/refman/5.7/en/flush.html1 @�@ 8� � "� 6#�KILL Syntax:
KILL [CONNECTION | QUERY] processlist_id
Each connection to mysqld runs in a separate thread. You can kill a
thread with the KILL processlist_id statement.
Thread processlist identifiers can be determined from the ID column of
the INFORMATION_SCHEMA PROCESSLIST table, the Id column of SHOW
PROCESSLIST output, and the PROCESSLIST_ID column of the Performance
Schema threads table. The value for the current thread is returned by
the CONNECTION_ID() function.
KILL permits an optional CONNECTION or QUERY modifier:
o KILL CONNECTION is the same as KILL with no modifier: It terminates
the connection associated with the given processlist_id, after
terminating any statement the connection is executing.
o KILL QUERY terminates the statement the connection is currently
executing, but leaves the connection itself intact.
The ability to see which threads are available to be killed depends on
the PROCESS privilege:
o Without PROCESS, you can see only your own threads.
o With PROCESS, you can see all threads.
The ability to kill threads and statements depends on the SUPER
privilege:
o Without SUPER, you can kill only your own threads and statements.
o With SUPER, you can kill all threads and statements.
You can also use the mysqladmin processlist and mysqladmin kill
commands to examine and kill threads.
*Note*:
You cannot use KILL with the Embedded MySQL Server library because the
embedded server merely runs inside the threads of the host application.
It does not create any connection threads of its own.
URL: https://dev.mysql.com/doc/refman/5.7/en/kill.html
https://dev.mysql.com/doc/refman/5.7/en/kill.html7 h�@ @� � "� 6#�LOAD INDEX Syntax:
LOAD INDEX INTO CACHE
tbl_index_list [, tbl_index_list] ...
tbl_index_list:
tbl_name
[PARTITION (partition_list)]
[{INDEX|KEY} (index_name[, index_name] ...)]
[IGNORE LEAVES]
partition_list: {
partition_name[, partition_name] ...
| ALL
}
The LOAD INDEX INTO CACHE statement preloads a table index into the key
cache to which it has been assigned by an explicit CACHE INDEX
statement, or into the default key cache otherwise.
LOAD INDEX INTO CACHE applies only to MyISAM tables, including
partitioned MyISAM tables. In addition, indexes on partitioned tables
can be preloaded for one, several, or all partitions.
The IGNORE LEAVES modifier causes only blocks for the nonleaf nodes of
the index to be preloaded.
IGNORE LEAVES is also supported for partitioned MyISAM tables.
URL: https://dev.mysql.com/doc/refman/5.7/en/load-index.html
https://dev.mysql.com/doc/refman/5.7/en/load-index.html2 Z�@ H� � "� 6#�RESET Syntax:
RESET reset_option [, reset_option] ...
reset_option: {
MASTER
| QUERY CACHE
| SLAVE
}
The RESET statement is used to clear the state of various server
operations. You must have the RELOAD privilege to execute RESET.
RESET acts as a stronger version of the FLUSH statement. See [HELP
FLUSH].
The RESET statement causes an implicit commit. See
https://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
The following list describes the permitted RESET statement reset_option
values:
o RESET MASTER
Deletes all binary logs listed in the index file, resets the binary
log index file to be empty, and creates a new binary log file.
o RESET QUERY CACHE
Removes all query results from the query cache.
*Note*:
The query cache is deprecated as of MySQL 5.7.20, and is removed in
MySQL 8.0. Deprecation includes RESET QUERY CACHE.
o RESET SLAVE
Makes the replica forget its replication position in the source
binary logs. Also resets the relay log by deleting any existing relay
log files and beginning a new one.
URL: https://dev.mysql.com/doc/refman/5.7/en/reset.html
https://dev.mysql.com/doc/refman/5.7/en/reset.html5 �@ P�/ � "� 6#�SHUTDOWN Syntax:
SHUTDOWN
This statement stops the MySQL server. It requires the SHUTDOWN
privilege.
SHUTDOWN provides an SQL-level interface to the same functionality
available using the mysqladmin shutdown command or the mysql_shutdown()
(https://dev.mysql.com/doc/c-api/5.7/en/mysql-shutdown.html) C API
function. A successful SHUTDOWN sequence consists of checking the
privileges, validating the arguments, and sending an OK packet to the
client. Then the server is shut down.
URL: https://dev.mysql.com/doc/refman/5.7/en/shutdown.html
https://dev.mysql.com/doc/refman/5.7/en/shutdown.html p� c�2�l #�ȟ�a, ^ ]���� $�E� �� � infimum supremum4 �@ v � "� 6#�EXPLAIN 0Syntax:
{EXPLAIN | DESCRIBE | DESC}
tbl_name [col_name | wild]
{EXPLAIN | DESCRIBE | DESC}
[explain_type]
{explainable_stmt | FOR CONNECTION connection_id}
explain_type: {
EXTENDED
| PARTITIONS
| FORMAT = format_name
}
format_name: {
TRADITIONAL
| JSON
}
explainable_stmt: {
SELECT statement
| DELETE statement
| INSERT statement
| REPLACE statement
| UPDATE statement
}
The DESCRIBE and EXPLAIN statements are synonyms. In practice, the
DESCRIBE keyword is more often used to obtain information about table
structure, whereas EXPLAIN is used to obtain a query execution plan
(that is, an explanation of how MySQL would execute a query).
URL: https://dev.mysql.com/doc/refman/5.7/en/explain.html
https://dev.mysql.com/doc/refman/5.7/en/explain.html4 �@ v � "� 6#�DESCRIBE 0Syntax:
{EXPLAIN | DESCRIBE | DESC}
tbl_name [col_name | wild]
{EXPLAIN | DESCRIBE | DESC}
[explain_type]
{explainable_stmt | FOR CONNECTION connection_id}
explain_type: {
EXTENDED
| PARTITIONS
| FORMAT = format_name
}
format_name: {
TRADITIONAL
| JSON
}
explainable_stmt: {
SELECT statement
| DELETE statement
| INSERT statement
| REPLACE statement
| UPDATE statement
}
The DESCRIBE and EXPLAIN statements are synonyms. In practice, the
DESCRIBE keyword is more often used to obtain information about table
structure, whereas EXPLAIN is used to obtain a query execution plan
(that is, an explanation of how MySQL would execute a query).
URL: https://dev.mysql.com/doc/refman/5.7/en/explain.html
https://dev.mysql.com/doc/refman/5.7/en/explain.html4 �@ v � "� 6$DESC 0Syntax:
{EXPLAIN | DESCRIBE | DESC}
tbl_name [col_name | wild]
{EXPLAIN | DESCRIBE | DESC}
[explain_type]
{explainable_stmt | FOR CONNECTION connection_id}
explain_type: {
EXTENDED
| PARTITIONS
| FORMAT = format_name
}
format_name: {
TRADITIONAL
| JSON
}
explainable_stmt: {
SELECT statement
| DELETE statement
| INSERT statement
| REPLACE statement
| UPDATE statement
}
The DESCRIBE and EXPLAIN statements are synonyms. In practice, the
DESCRIBE keyword is more often used to obtain information about table
structure, whereas EXPLAIN is used to obtain a query execution plan
(that is, an explanation of how MySQL would execute a query).
URL: https://dev.mysql.com/doc/refman/5.7/en/explain.html
https://dev.mysql.com/doc/refman/5.7/en/explain.html1 +�@ (� � "� 6$HELP STATEMENT 0Syntax:
HELP 'search_string'
The HELP statement returns online information from the MySQL Reference
Manual. Its proper operation requires that the help tables in the mysql
database be initialized with help topic information (see
https://dev.mysql.com/doc/refman/5.7/en/server-side-help-support.html).
The HELP statement searches the help tables for the given search string
and displays the result of the search. The search string is not
case-sensitive.
The search string can contain the wildcard characters % and _. These
have the same meaning as for pattern-matching operations performed with
the LIKE operator. For example, HELP 'rep%' returns a list of topics
that begin with rep.
The HELP statement does not require a terminator such as ; or \G.
URL: https://dev.mysql.com/doc/refman/5.7/en/help.html
https://dev.mysql.com/doc/refman/5.7/en/help.html0 k�@ 0� � "� 6$ USE 0Syntax:
USE db_name
The USE statement tells MySQL to use the named database as the default
(current) database for subsequent statements. This statement requires
some privilege for the database or some object within it.
The named database remains the default until the end of the session or
another USE statement is issued:
USE db1;
SELECT COUNT(*) FROM mytable; # selects from db1.mytable
USE db2;
SELECT COUNT(*) FROM mytable; # selects from db2.mytable
The database name must be specified on a single line. Newlines in
database names are not supported.
URL: https://dev.mysql.com/doc/refman/5.7/en/use.html
https://dev.mysql.com/doc/refman/5.7/en/use.htmlA �g�@ 8�� � "� 6$-MERGE 1The MERGE storage engine, also known as the MRG_MyISAM engine, is a
collection of identical MyISAM tables that can be used as one.
"Identical" means that all tables have identical column data types and
index information. You cannot merge MyISAM tables in which the columns
are listed in a different order, do not have exactly the same data
types in corresponding columns, or have the indexes in different order.
However, any or all of the MyISAM tables can be compressed with
myisampack. See
https://dev.mysql.com/doc/refman/5.7/en/myisampack.html. Differences
between tables such as these do not matter:
o Names of corresponding columns and indexes can differ.
o Comments for tables, columns, and indexes can differ.
o Table options such as AVG_ROW_LENGTH, MAX_ROWS, or PACK_KEYS can
differ.
URL: https://dev.mysql.com/doc/refman/5.7/en/merge-storage-engine.html
mysql> CREATE TABLE t1 (
-> a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> message CHAR(20)) ENGINE=MyISAM;
mysql> CREATE TABLE t2 (
-> a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> message CHAR(20)) ENGINE=MyISAM;
mysql> INSERT INTO t1 (message) VALUES ('Testing'),('table'),('t1');
mysql> INSERT INTO t2 (message) VALUES ('Testing'),('table'),('t2');
mysql> CREATE TABLE total (
-> a INT NOT NULL AUTO_INCREMENT,
-> message CHAR(20), INDEX(a))
-> ENGINE=MERGE UNION=(t1,t2) INSERT_METHOD=LAST;
https://dev.mysql.com/doc/refman/5.7/en/merge-storage-engine.html p c��a, $�