| 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 : /mysql5.7.18/data/Data/mysql/ |
Upload File : |
aՏK "� @ � ! ) ���� ���� � � ���� ���� ���� ���� & & ���� ���� ���������������� ���� ���� �������������� aՏK "��F8 <� 3 0 �F8 <��x� "� ���� ���� ���� ���� ���� ���� ���� ���� �i� ���������������������������������������������������������������������������������������������������������������������������� ���� ���� � � ���� ���� �i�
! " # $ % & ���� ���� ���� ���� ���� ���� �i� ���������������������������������������������������������������������������������������������������������������������������� ���� ���� ���� ���� ���� ���� �i� ' (���������������������������������������������������������������������������������������������������������������� �x� "�"�eQ �������� "�E� 0 � - . � 2 infimum supremum
!
)
# 1
+ 9
9
A
J I
Z Q
l
Y
} a
� i
� q
� y
� �
� �
� �
� �
�
�
! �
+ �
4 �
E ! �
M " �
Y # �
c $ �
r % �
� & �
� @ �
� A
� B
� C
� F
� G !
� H)
� I 1
� J 9
K A
LI
) N Q
5 O Y
G Q a
T R i
b T q
k U y�� x V pxD��t@ � � c"�eQ "�弅 �������� <�E� �� h r � infimum supremum@ �& � @ NLOOP � @ !�VSHOW PRIVILEGES x '@ )�dDIV � ( p c弅 <��&�� ���� 1!E� 9 � � � infimum supremum0r��@ � "� 6�JOIN MySQL supports the following JOIN syntaxes 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
| join_table
table_factor:
tbl_name [PARTITION (partition_names)]
[[AS] alias] [index_hint_list]
| table_subquery [AS] alias
| ( table_references )
join_table:
table_reference [INNER | CROSS] JOIN table_factor [join_condition]
| table_reference STRAIGHT_JOIN table_factor
| table_reference STRAIGHT_JOIN table_factor ON conditional_expr
| table_reference {LEFT|RIGHT} [OUTER] JOIN table_reference join_condition
| table_reference NATURAL [{LEFT|RIGHT} [OUTER]] JOIN table_factor
join_condition:
ON conditional_expr
| USING (column_list)
index_hint_list:
index_hint [, index_hint] ...
index_hint:
USE {INDEX|KEY}
[FOR {JOIN|ORDER BY|GROUP BY}] ([index_list])
| IGNORE {INDEX|KEY}
[FOR {JOIN|ORDER BY|GROUP BY}] (index_list)
| 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 option, including a comma-separated list of 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---in
other words, any partitions or subpartitions not named in the list are
ignored For more information, see
http://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
The syntax of table_factor is extended in comparison with the SQL
Standard. The latter accepts only table_reference, not a list of them
inside a pair of parentheses.
This is a conservative extension if we consider each comma in a list of
table_reference items 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
http://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
http://dev.mysql.com/doc/refman/5.7/en/index-hints.html.
URL: http://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;
http://dev.mysql.com/doc/refman/5.7/en/join.html<��r�@ � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlJ ˀ@ r "� 6�CONTAINS Contains(g1, g2)
MBRContains() and Contains() are synonyms. For more information, see
the description of MBRContains().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlJ ��@ (] "� 6�SRID %SRID(g)
ST_SRID() and SRID() are synonyms. For more information, see the
description of ST_SRID().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html> (�@ 0� "� 6�VARIANCE Syntax:
VARIANCE(expr)
Returns the population standard variance of expr. This is an extension
to standard SQL. The standard SQL function VAR_POP() can be used
instead.
If there are no matching rows, VARIANCE() returns NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html7 ��@ 8G "� 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: http://dev.mysql.com/doc/refman/5.7/en/drop-server.html
http://dev.mysql.com/doc/refman/5.7/en/drop-server.htmlU��ڀ@ @ "� 6�ST_GEOMETRYN ST_GeometryN(gc, N)
Returns the N-th geometry in the GeometryCollection value gc.
Geometries are numbered beginning with 1.
URL: http://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) |
+-------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html= �@ H� "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html<��ԁ@ P
"� 6 CONCAT &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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlH �@ X� "� 6 GEOMETRY 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: http://dev.mysql.com/doc/refman/5.7/en/gis-geometry-class-hierarchy.html
http://dev.mysql.com/doc/refman/5.7/en/gis-geometry-class-hierarchy.html<o��@ `�
"� 6CHAR 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.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlK ͂@ hu "� 6$ASYMMETRIC_DECRYPT Syntax:
ASYMMETRIC_DECRYPT(algorithm, crypt_str, key_str)
Decrypts an encrypted string using the given algorithm and key string,
and returns the resulting cleartext 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: http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html? �@ p� "� 60SHOW 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: http://dev.mysql.com/doc/refman/5.7/en/show-create-trigger.html
http://dev.mysql.com/doc/refman/5.7/en/show-create-trigger.htmlAd�s�@ xu
"� 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 field will be NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-create-procedure.html
mysql> SHOW CREATE PROCEDURE test.simpleproc\G
*************************** 1. row ***************************
Procedure: simpleproc
sql_mode:
Create Procedure: CREATE PROCEDURE `simpleproc`(OUT param1 INT)
BEGIN
SELECT COUNT(*) INTO param1 FROM t;
END
character_set_client: latin1
collation_connection: latin1_swedish_ci
Database Collation: latin1_swedish_ci
mysql> SHOW CREATE FUNCTION test.hello\G
*************************** 1. row ***************************
Function: hello
sql_mode:
Create Function: CREATE FUNCTION `hello`(s CHAR(20))
RETURNS CHAR(50)
RETURN CONCAT('Hello, ',s,'!')
character_set_client: latin1
collation_connection: latin1_swedish_ci
Database Collation: latin1_swedish_ci
http://dev.mysql.com/doc/refman/5.7/en/show-create-procedure.html0 @ �[ "� 6HOPEN Syntax:
OPEN cursor_name
This statement opens a previously declared cursor. For an example, see
http://dev.mysql.com/doc/refman/5.7/en/cursors.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/open.html
http://dev.mysql.com/doc/refman/5.7/en/open.htmlT ��@ � "� 6TST_INTERSECTS ST_Intersects(g1, g2)
Returns 1 or 0 to indicate whether g1 spatially intersects g2.
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html p p�T c�&�� 1!��͒ q�E� ;a� 9� infimum supremum<��ԁ@
"� 6 CONCAT &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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlH �@ � "� 6 GEOMETRY 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: http://dev.mysql.com/doc/refman/5.7/en/gis-geometry-class-hierarchy.html
http://dev.mysql.com/doc/refman/5.7/en/gis-geometry-class-hierarchy.html<o��@ �
"� 6CHAR 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.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlK ͂@ (u "� 6$ASYMMETRIC_DECRYPT Syntax:
ASYMMETRIC_DECRYPT(algorithm, crypt_str, key_str)
Decrypts an encrypted string using the given algorithm and key string,
and returns the resulting cleartext 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: http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html? �@ 0� "� 60SHOW 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: http://dev.mysql.com/doc/refman/5.7/en/show-create-trigger.html
http://dev.mysql.com/doc/refman/5.7/en/show-create-trigger.htmlAd�s�@ 8u
"� 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 field will be NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-create-procedure.html
mysql> SHOW CREATE PROCEDURE test.simpleproc\G
*************************** 1. row ***************************
Procedure: simpleproc
sql_mode:
Create Procedure: CREATE PROCEDURE `simpleproc`(OUT param1 INT)
BEGIN
SELECT COUNT(*) INTO param1 FROM t;
END
character_set_client: latin1
collation_connection: latin1_swedish_ci
Database Collation: latin1_swedish_ci
mysql> SHOW CREATE FUNCTION test.hello\G
*************************** 1. row ***************************
Function: hello
sql_mode:
Create Function: CREATE FUNCTION `hello`(s CHAR(20))
RETURNS CHAR(50)
RETURN CONCAT('Hello, ',s,'!')
character_set_client: latin1
collation_connection: latin1_swedish_ci
Database Collation: latin1_swedish_ci
http://dev.mysql.com/doc/refman/5.7/en/show-create-procedure.html0 @ @[ "� 6HOPEN Syntax:
OPEN cursor_name
This statement opens a previously declared cursor. For an example, see
http://dev.mysql.com/doc/refman/5.7/en/cursors.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/open.html
http://dev.mysql.com/doc/refman/5.7/en/open.htmlT ��@ Hc "� 6TST_INTERSECTS ST_Intersects(g1, g2)
Returns 1 or 0 to indicate whether g1 spatially intersects g2.
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html< ل@ Pr "� 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, convert
the string to a nonbinary 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
http://dev.mysql.com/doc/refman/5.7/en/charset-unicode-sets.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html: W�@ X � "� 6lCREATE TRIGGER (Syntax:
CREATE
[DEFINER = { user | CURRENT_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
http://dev.mysql.com/doc/refman/5.7/en/trigger-syntax.html.
CREATE TRIGGER requires the TRIGGER privilege for the table associated
with the trigger. The statement might also require the SUPER privilege,
depending on the DEFINER value, as described later in this section. If
binary logging is enabled, CREATE TRIGGER might require the SUPER
privilege, as described in
http://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.
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: http://dev.mysql.com/doc/refman/5.7/en/create-trigger.html
http://dev.mysql.com/doc/refman/5.7/en/create-trigger.htmlC0��@ `� "� 6xMONTH 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MONTH('2008-02-03');
-> 2
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlK�0�@ h� "� 6�ASYMMETRIC_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: http://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 @cleartext = ASYMMETRIC_DECRYPT('RSA', @ciphertext, @pub);
-- Encrypt using public key, decrypt using private key
SET @ciphertext = ASYMMETRIC_ENCRYPT('RSA', 'The quick brown fox', @pub);
SET @cleartext = ASYMMETRIC_DECRYPT('RSA', @ciphertext, @priv);
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html9 #�@ p� "� 6�SHOW 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 to match (not trigger names) 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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
For the trigger ins_sum as defined in
http://dev.mysql.com/doc/refman/5.7/en/triggers.html, the output of
this statement 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: 2013-07-09 10:39:34.96
sql_mode: NO_ENGINE_SUBSTITUTION
Definer: me@localhost
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latin1_swedish_ci
URL: http://dev.mysql.com/doc/refman/5.7/en/show-triggers.html
http://dev.mysql.com/doc/refman/5.7/en/show-triggers.htmlM ʀ@ x�y "� 6�ISCLOSED
IsClosed(ls)
ST_IsClosed() and IsClosed() are synonyms. For more information, see
the description of ST_IsClosed().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html p�� c��͒ q�EHc] �RE� .;� +�
infimum supremum2�
�@ � "� 6�REGEXP &Syntax:
expr REGEXP pat, expr RLIKE pat
Performs a pattern match of a string expression expr against a pattern
pat. The pattern can be an extended regular expression, the syntax for
which is discussed later in this section. Returns 1 if expr matches
pat; otherwise it returns 0. If either expr or pat is NULL, the result
is NULL. RLIKE is a synonym for REGEXP.
The pattern need not be a literal string. For example, it can be
specified as a string expression or table column.
*Note*:
Because MySQL uses the C escape syntax in strings (for example, \n to
represent the newline character), you must double any \ that you use in
your REGEXP strings.
REGEXP is not case sensitive, except when used with binary strings.
URL: http://dev.mysql.com/doc/refman/5.7/en/regexp.html
mysql> SELECT 'Monty!' REGEXP '.*';
-> 1
mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
-> 1
mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';
-> 1 0
mysql> SELECT 'a' REGEXP '^[a-d]';
-> 1
http://dev.mysql.com/doc/refman/5.7/en/regexp.htmlM]���@ � "� 6�ST_POINTN
ST_PointN(ls, N)
Returns the N-th Point in the Linestring value ls. Points are numbered
beginning with 1.
URL: http://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) |
+----------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html. ,�@ � "� 6�IF 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
http://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html. The
IF statement can have THEN, ELSE, and ELSEIF clauses, and it is
terminated with END IF.
If the 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: http://dev.mysql.com/doc/refman/5.7/en/if.html
http://dev.mysql.com/doc/refman/5.7/en/if.html@ &�@ (� "� 6�VALIDATE_PASSWORD_STRENGTH Syntax:
VALIDATE_PASSWORD_STRENGTH(str)
Given an argument representing a cleartext password, this function
returns an integer to indicate how strong the password is. The return
value ranges from 0 (weak) to 100 (strong).
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlJ À@ 0j "� 6�WITHIN Within(g1, g2)
MBRWithin() and Within() are synonyms. For more information, see the
description of MBRWithin().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html8 ��@ 81 "� 6�SHOW PLUGINS Syntax:
SHOW PLUGINS
SHOW PLUGINS displays information about server plugins. Plugin
information is also available in the INFORMATION_SCHEMA.PLUGINS table.
See http://dev.mysql.com/doc/refman/5.7/en/plugins-table.html.
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: http://dev.mysql.com/doc/refman/5.7/en/show-plugins.html
http://dev.mysql.com/doc/refman/5.7/en/show-plugins.html3 S�@ @ � "� 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
http://dev.mysql.com/doc/refman/5.7/en/sql-syntax-prepared-statements.h
tml.
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
http://dev.mysql.com/doc/refman/5.7/en/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
http://dev.mysql.com/doc/refman/5.7/en/user-variables.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/prepare.html
http://dev.mysql.com/doc/refman/5.7/en/prepare.html7 (�@ H� "� 6�LOCK 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 later in this
section.
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. If you
lock a table explicitly with LOCK TABLES, any tables used in triggers
are also locked implicitly, as described in
http://dev.mysql.com/doc/refman/5.7/en/lock-tables-and-triggers.html.
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: http://dev.mysql.com/doc/refman/5.7/en/lock-tables.html
http://dev.mysql.com/doc/refman/5.7/en/lock-tables.html< �@ P� "� 6SHOW 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.
mysql> SHOW BINARY LOGS;
+---------------+-----------+
| Log_name | File_size |
+---------------+-----------+
| binlog.000015 | 724935 |
| binlog.000016 | 733481 |
+---------------+-----------+
URL: http://dev.mysql.com/doc/refman/5.7/en/show-binary-logs.html
http://dev.mysql.com/doc/refman/5.7/en/show-binary-logs.htmlH 5�@ X� "� 6POLYGON Polygon(ls1, ls2, ...)
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: http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlC:��@ `n "� 6 MINUTE Syntax:
MINUTE(time)
Returns the minute for time, in the range 0 to 59.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MINUTE('2008-02-03 10:05:03');
-> 5
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html< ��@ h1 ! "� 6,MID &Syntax:
MID(str,pos,len)
MID(str,pos,len) is a synonym for SUBSTRING(str,pos,len).
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlA0�@ p�� " "� 68CONNECTION_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: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT CONNECTION_ID();
-> 23786
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html p � � cEHc] �Rh��_ �.E� 9р
7P infimum supremum2 ��@ � # "� 6DDELETE 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,...)]
[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
http://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
http://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]
Or:
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].
The speed of delete operations may also be affected by factors
discussed in
http://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 Tables
DELETE supports explicit partition selection using the PARTITION
option, which takes a comma-separated list of the 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 option can also be used in multiple-table DELETE
statements. You can use up to one such option per table named in the
FROM option.
See http://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html,
for more information and examples.
URL: http://dev.mysql.com/doc/refman/5.7/en/delete.html
http://dev.mysql.com/doc/refman/5.7/en/delete.htmlAM���@ � $ "� 6PJSON_SEARCH 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
http://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.
URL: http://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" |
+-------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html1 i�@ � % "� 6\CLOSE Syntax:
CLOSE cursor_name
This statement closes a previously opened cursor. For an example, see
http://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: http://dev.mysql.com/doc/refman/5.7/en/close.html
http://dev.mysql.com/doc/refman/5.7/en/close.html<Q�@ (� & "� 6hREPLACE 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
-> 'WwWwWw.mysql.com'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html/ ��@ 0C ' "� 6tUSE Syntax:
USE db_name
The USE db_name statement tells MySQL to use the db_name database as
the default (current) database for subsequent statements. The 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
URL: http://dev.mysql.com/doc/refman/5.7/en/use.html
http://dev.mysql.com/doc/refman/5.7/en/use.htmlB��@ 8� ( "� 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 version returns the result where value=compare_value. The
second version returns the result for the first condition that is true.
If there was no matching result value, the result after ELSE is
returned, or NULL if there is no ELSE part.
URL: http://dev.mysql.com/doc/refman/5.7/en/control-flow-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
http://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html> %�@ @� ) "� 6�SHOW MASTER STATUS Syntax:
SHOW MASTER STATUS
This statement provides status information about the binary log files
of the master. It requires either the SUPER or REPLICATION CLIENT
privilege.
Example:
mysql> SHOW MASTER STATUS\G
*************************** 1. row ***************************
File: master-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: http://dev.mysql.com/doc/refman/5.7/en/show-master-status.html
http://dev.mysql.com/doc/refman/5.7/en/show-master-status.htmlC���@ H� * "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p,� ch��_ �.U+�3
/0E� ;̀ 8X
infimum supremumC�7�@ � + "� 6�TIMESTAMPDIFF 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlD ��@ � , "� 6�SPATIAL #For MyISAM and (as of MySQL 5.7.5) InnoDB 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)) ENGINE=MyISAM;
o With ALTER TABLE:
ALTER TABLE geom ADD SPATIAL INDEX(g);
o With CREATE INDEX:
CREATE SPATIAL INDEX sp_index 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 sp_index 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: http://dev.mysql.com/doc/refman/5.7/en/creating-spatial-indexes.html
http://dev.mysql.com/doc/refman/5.7/en/creating-spatial-indexes.html</��@ d - "� 6�REVERSE &Syntax:
REVERSE(str)
Returns the string str with the order of the characters reversed.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT REVERSE('abc');
-> 'cba'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@P��@ (� . "� 6�ISNULL Syntax:
ISNULL(expr)
If expr is NULL, ISNULL() returns 1, otherwise it returns 0.
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT ISNULL(1+1);
-> 0
mysql> SELECT ISNULL(1/0);
-> 1
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlMi���@ 0� / "� 6�ST_STARTPOINT
ST_StartPoint(ls)
Returns the Point that is the start point of the LineString value ls.
URL: http://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) |
+------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html@ �@ 8� 0 "� 6�BINARY BINARY(M)
The BINARY type is similar to the CHAR type, but stores binary byte
strings rather than nonbinary character strings. M represents the
column length in bytes.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html0 �@ @� 1 "� 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
http://dev.mysql.com/doc/refman/5.7/en/storage-requirements.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/blob.html
http://dev.mysql.com/doc/refman/5.7/en/blob.htmlAр��@ H 2 "� 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html@%h@ P* 3 "� 6<= Syntax:
<=
Less than or equal:
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 0.1 <= 2;
-> 1
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html9 �@ X� 4 "� 6SHOW 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*:
These statements are deprecated and will be removed in a future MySQL
release. Use the Performance Schema instead; see
http://dev.mysql.com/doc/refman/5.7/en/performance-schema.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-profiles.html
http://dev.mysql.com/doc/refman/5.7/en/show-profiles.html2 �@ `
r 5 "� 6 UPDATE Syntax:
Single-table syntax:
UPDATE [LOW_PRIORITY] [IGNORE] table_reference
SET col_name1={expr1|DEFAULT} [, col_name2={expr2|DEFAULT}] ...
[WHERE where_condition]
[ORDER BY ...]
[LIMIT row_count]
Multiple-table syntax:
UPDATE [LOW_PRIORITY] [IGNORE] table_references
SET col_name1={expr1|DEFAULT} [, col_name2={expr2|DEFAULT}] ...
[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 option 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.
See http://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html,
for more information and examples.
where_condition is an expression that evaluates to true for each row to
be updated. For expression syntax, see
http://dev.mysql.com/doc/refman/5.7/en/expressions.html.
table_references and where_condition are specified as described in
http://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
http://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#ignore-strict-co
mparison.
URL: http://dev.mysql.com/doc/refman/5.7/en/update.html
http://dev.mysql.com/doc/refman/5.7/en/update.html0 �@ h
6 "� 6(CASE 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 expression, which differs from the CASE statement
described here. See
http://dev.mysql.com/doc/refman/5.7/en/control-flow-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
http://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: http://dev.mysql.com/doc/refman/5.7/en/case.html
http://dev.mysql.com/doc/refman/5.7/en/case.htmlI<���@ pr 7 "� 64ST_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
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 valid geometry byte string, an
ER_GIS_INVALID_DATA error occurs.
URL: http://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) |
+---------------------------------+
mysql> SELECT ST_AsText(ST_Simplify(@g));
http://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html3 �@ x� 8 "� 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: http://dev.mysql.com/doc/refman/5.7/en/execute.html
http://dev.mysql.com/doc/refman/5.7/en/execute.html p� G cU+�3 /0�D��
t$E� ;�� 4� infimum supremum6 W�@ � 9 "� 6LDROP 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: http://dev.mysql.com/doc/refman/5.7/en/drop-index.html
http://dev.mysql.com/doc/refman/5.7/en/drop-index.htmlBI{@ c : "� 6XABS Syntax:
ABS(X)
Returns the absolute value of X.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ABS(2);
-> 2
mysql> SELECT ABS(-32);
-> 32
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlCJ��@ � ; "� 6dIS_IPV4 Syntax:
IS_IPV4(expr)
Returns 1 if the argument is a valid IPv4 address specified as a
string, 0 otherwise.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html= �@ (� < "� 6pPOLYFROMWKB !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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlG ��@ 0e = "� 6|NOT LIKE &Syntax:
expr NOT LIKE pat [ESCAPE 'escape_char']
This is the same as NOT (expr LIKE pat [ESCAPE 'escape_char']).
URL: http://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html<,��@ 8N > "� 6�SPACE &Syntax:
SPACE(N)
Returns a string consisting of N space characters.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT SPACE(6);
-> ' '
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html>}�@ @� ? "� 6�MAX 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
-> FROM student
-> GROUP BY student_name;
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html? B�@ H� @ "� 6�CREATE FUNCTION UDF Syntax:
CREATE [AGGREGATE] FUNCTION function_name RETURNS {STRING|INTEGER|REAL|DECIMAL}
SONAME shared_library_name
A user-defined function (UDF) is a way to extend MySQL with a new
function that works like a native (built-in) MySQL function such as
ABS() or CONCAT().
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.
shared_library_name is the base name of the shared library file that
contains 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
http://dev.mysql.com/doc/refman/5.7/en/udf-compiling.html.
To create a function, you must have the INSERT privilege for the mysql
database. This is necessary because CREATE FUNCTION adds a row to the
mysql.func system table that records the function's name, type, and
shared library name. If you do not have this table, you should run the
mysql_upgrade command to create it. See
http://dev.mysql.com/doc/refman/5.7/en/mysql-upgrade.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/create-function-udf.html
http://dev.mysql.com/doc/refman/5.7/en/create-function-udf.htmlG A�@ P� A "� 6�TIMESTAMP TIMESTAMP[(fsp)]
A timestamp. The range is '1970-01-01 00:00:01.000000' UTC to
'2038-01-19 03:14:07.999999' 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
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html).
By default, explicit_defaults_for_timestamp is disabled and 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.
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.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.htmlK 5�@ X� B "� 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: http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html7 /�@ `� C "� 6�CACHE INDEX Syntax:
CACHE INDEX
tbl_index_list [, tbl_index_list] ...
[PARTITION (partition_list | ALL)]
IN key_cache_name
tbl_index_list:
tbl_name [[INDEX|KEY] (index_name[, index_name] ...)]
partition_list:
partition_name[, partition_name][, ...]
The CACHE INDEX statement assigns table indexes to a specific key
cache. It is used only for 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: http://dev.mysql.com/doc/refman/5.7/en/cache-index.html
http://dev.mysql.com/doc/refman/5.7/en/cache-index.html@�r�@ h� D "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html3 5�@ p� E "� 6�HANDLER 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: http://dev.mysql.com/doc/refman/5.7/en/handler.html
http://dev.mysql.com/doc/refman/5.7/en/handler.html W@ x � F "� 6�HELP_DATE This help information was generated from the MySQL 5.7 Reference Manual
on: 2017-03-17
8%��@ �Q G "� 6�RENAME TABLE (Syntax:
RENAME TABLE tbl_name TO new_tbl_name
[, tbl_name2 TO new_tbl_name2] ...
This statement renames one or more tables. The rename operation is done
atomically, which means that no other session can access any of the
tables while the rename is running.
For example, a table named old_table can be renamed to new_table as
shown here:
URL: http://dev.mysql.com/doc/refman/5.7/en/rename-table.html
RENAME TABLE old_table TO new_table;
http://dev.mysql.com/doc/refman/5.7/en/rename-table.htmlA ��@ �� H "� 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: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.htmlA��ۂ@ ��� I "� 6 JSON_EXTRACT 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: http://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] |
+-----------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html p$/
�p c�D�� t$?4�
�nE� ;l� :" infimum supremumB����@ � J "� 6MOD Syntax:
MOD(N,M), N % M, N MOD M
Modulo operation. Returns the remainder of N divided by M.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlJ=�;�@ K "� 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: http://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 |
+------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html0 �@ r L "� 60HELP STATEMENT Syntax:
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
http://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.
URL: http://dev.mysql.com/doc/refman/5.7/en/help.html
http://dev.mysql.com/doc/refman/5.7/en/help.html< z@ ( M "� 6<UCASE &Syntax:
UCASE(str)
UCASE() is a synonym for UPPER().
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html> �@ 0� N "� 6HSHOW 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.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-binlog-events.html
http://dev.mysql.com/doc/refman/5.7/en/show-binlog-events.html= '�@ 8� O "� 6TMPOLYFROMWKB !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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html3 ��@ @K P "� 6`ITERATE Syntax:
ITERATE label
ITERATE can appear only within LOOP, REPEAT, and WHILE statements.
ITERATE means "start the loop again."
URL: http://dev.mysql.com/doc/refman/5.7/en/iterate.html
http://dev.mysql.com/doc/refman/5.7/en/iterate.html. ,�@ H� Q "� 6lDO 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.
As of MySQL 5.7.8, DO statement errors that previously were converted
to warnings are returned as errors.
URL: http://dev.mysql.com/doc/refman/5.7/en/do.html
http://dev.mysql.com/doc/refman/5.7/en/do.html< F�@ P� R "� 6xCHAR_LENGTH &Syntax:
CHAR_LENGTH(str)
Returns the length of the string str, measured in characters. A
multibyte character counts as a single character. This means that for a
string containing five 2-byte characters, LENGTH() returns 10, whereas
CHAR_LENGTH() returns 5.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlG �@ X� S "� 6�DATE 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.htmlK���@ `W T "� 6�ST_ASTEXT !ST_AsText(g), ST_AsWKT(g)
Converts a value in internal geometry format to its WKT representation
and returns the string result.
The result is NULL if the geometry argument is NULL. If the argument is
not a syntactically well-formed geometry, an ER_GIS_INVALID_DATA error
occurs as of MySQL 5.7.5. The result is NULL prior to MySQL 5.7.5.
URL: http://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) |
+--------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.htmlD �@ h � U "� 6�JSON_TYPE JSON_TYPE(json_val)
Returns a utf8mb4 string indicating the type of a JSON value:
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: http://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html
http://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html9�<�@ p
� V "� 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 elements 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: http://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 |
+------+------+------+------+---------+
http://dev.mysql.com/doc/refman/5.7/en/xml-functions.html@ w�@ x W "� 6�OLD_PASSWORD Syntax:
OLD_PASSWORD(str)
OLD_PASSWORD() was added when the implementation of PASSWORD() was
changed in MySQL 4.1 to improve security. OLD_PASSWORD() returns the
value of the pre-4.1 implementation of PASSWORD() as a string, and is
intended to permit you to reset passwords for any pre-4.1 clients that
need to connect to your MySQL server without locking them out. See
http://dev.mysql.com/doc/refman/5.7/en/password-hashing.html.
The return value is a nonbinary string in the connection character set.
*Note*:
Passwords that use the pre-4.1 hashing method are less secure than
passwords that use the native password hashing method and should be
avoided. Pre-4.1 passwords are deprecated and support for them is
removed in MySQL 5.7.5. Consequently, OLD_PASSWORD() is deprecated and
is removed in MySQL 5.7.5.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html<�@ � X "� 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
http://dev.mysql.com/doc/refman/5.7/en/locale-support.html). If no
locale is specified, the default is 'en_US'.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html<0��@ ��N Y "� 6�BIT_LENGTH &Syntax:
BIT_LENGTH(str)
Returns the length of the string str in bits.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT BIT_LENGTH('text');
-> 32
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html p[�� c?4� �n㥴�
K�E� ;Q� 4� infimum supremumJ ـ@ � Z "� 6�EXTERIORRING ExteriorRing(poly)
ST_ExteriorRing() and ExteriorRing() are synonyms. For more
information, see the description of ST_ExteriorRing().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html= �@ � [ "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html@��@ � \ "� 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
http://dev.mysql.com/doc/refman/5.7/en/type-conversion.html, but
applied to all the three arguments.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlH ��@ (f ] "� 6MULTIPOLYGON MultiPolygon(poly1, poly2, ...)
Constructs a MultiPolygon value from a set of Polygon or WKB Polygon
arguments.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html<7��@ 0� ^ "� 6LEFT &Syntax:
LEFT(str,len)
Returns the leftmost len characters from the string str, or NULL if any
argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LEFT('foobarbar', 5);
-> 'fooba'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlM��ށ@ 8 _ "� 6ST_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).
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, and NULL if ls is NULL.
URL: http://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 |
+------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlN r�@ @ ` "� 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: http://dev.mysql.com/doc/refman/5.7/en/query-cache-status-and-maintenance.html
http://dev.mysql.com/doc/refman/5.7/en/query-cache-status-and-maintenance.html@ j�@ H a "� 65SET 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 http://dev.mysql.com/doc/refman/5.7/en/limits-frm-file.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.htmlB���@ P C b "� 6BRAND 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: http://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)
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html<b �@ X c "� 6ORPAD &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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT RPAD('hi',5,'?');
-> 'hi???'
mysql> SELECT RPAD('hi',1,'?');
-> 'h'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlA /�@ `� d "� 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: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html<��4�@ hS e "� 6iELT &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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
-> 'ej'
mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
-> 'foo'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlE �Ձ@ p� f "� 6vST_LONGFROMGEOHASH ST_LongFromGeoHash(geohash_str)
Returns the longitude from a geohash string value, as a DOUBLE value in
the range [−180, 180]. The result is NULL if any argument is NULL. An
error occurs if the argument is invalid.
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: http://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 |
+-------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.html6 ڂ@ xm g "� 6�ALTER VIEW (Syntax:
ALTER
[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
[DEFINER = { user | CURRENT_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 and the effect is the same as
for CREATE OR REPLACE 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: http://dev.mysql.com/doc/refman/5.7/en/alter-view.html
http://dev.mysql.com/doc/refman/5.7/en/alter-view.html: �@ �� h "� 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
http://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.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-databases.html
http://dev.mysql.com/doc/refman/5.7/en/show-databases.htmlClT�@ �a i "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html<����@ �� j "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html7 ��@ �˟ k "� 6�SHOW EVENTS Syntax:
SHOW EVENTS [{FROM | IN} schema_name]
[LIKE 'pattern' | WHERE expr]
This statement displays information about Event Manager events. 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: 10
Interval field: SECOND
Starts: 2006-02-09 10:41:23
Ends: NULL
Status: ENABLED
Originator: 0
character_set_client: latin1
collation_connection: latin1_swedish_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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-events.html
http://dev.mysql.com/doc/refman/5.7/en/show-events.html p"�nZ c㥴� K�,��u
��E� 1�� /� infimum supremumG�&�@ J l "� 6�JSON_INSERT 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: http://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]"} |
+----------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlG��0�@ � m "� 6�JSON_UNQUOTE JSON_UNQUOTE(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: http://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 |
+----------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html@ 1�@ � n "� 6�LONGTEXT 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html0 ��@ ( o "� 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.
If you have the PROCESS privilege, you can see all threads. If you have
the SUPER privilege, you can kill all threads and statements.
Otherwise, you can see and kill only your own 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: http://dev.mysql.com/doc/refman/5.7/en/kill.html
http://dev.mysql.com/doc/refman/5.7/en/kill.htmlJ ˀ@ 0r p "� 6�DISJOINT Disjoint(g1, g2)
MBRDisjoint() and Disjoint() are synonyms. For more information, see
the description of MBRDisjoint().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html<c �@ 8 q "� 6LPAD &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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LPAD('hi',4,'??');
-> '??hi'
mysql> SELECT LPAD('hi',1,'??');
-> 'h'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlJ ˀ@ @r r "� 6OVERLAPS Overlaps(g1, g2)
MBROverlaps() and Overlaps() are synonyms. For more information, see
the description of MBROverlaps().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlM o�@ H s "� 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: http://dev.mysql.com/doc/refman/5.7/en/set-global-sql-slave-skip-counter.html
http://dev.mysql.com/doc/refman/5.7/en/set-global-sql-slave-skip-counter.htmlU �@ P� t "� 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html= �@ X� u "� 69PROCEDURE 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: http://dev.mysql.com/doc/refman/5.7/en/procedure-analyse.html
http://dev.mysql.com/doc/refman/5.7/en/procedure-analyse.html ��@ ` � v "� 6FHELP_VERSION This help information was generated from the MySQL 5.7 Reference Manual
on: 2017-03-17 (revision: 51284)
This information applies to MySQL 5.7 through 5.7.19.
< ��@ h/ w "� 6SCHARACTER_LENGTH &Syntax:
CHARACTER_LENGTH(str)
CHARACTER_LENGTH() is a synonym for CHAR_LENGTH().
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html; �@ p� 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: http://dev.mysql.com/doc/refman/5.7/en/show-privileges.html
http://dev.mysql.com/doc/refman/5.7/en/show-privileges.html= �@ x � y "� 6mCREATE TABLESPACE ( & E�http://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html= W�@ �� z "� 6zST_GEOMFROMTEXT ST_GeomFromText(wkt[, srid]), ST_GeometryFromText(wkt[, srid])
Constructs a geometry value of any type using its WKT representation
and SRID.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html<@ �4 { "� 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html=���@ �Ѝ | "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/logical-operators.html p'T &- c,��u ��?K� 3�
?� Syntax:
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 [=] comment_text]
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.
Considerations for InnoDB
An InnoDB tablespace created using CREATE TABLESPACE is referred to as
a general tablespace. This is a shared tablespace, similar to the
system 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 MySQL 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
http://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 MySQL Cluster Disk Data
tables (see
http://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 MySQL 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).
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 http://dev.mysql.com/doc/refman/5.7/en/files-table.html.)
Options
o ADD DATAFILE: Defines the name of a tablespace data file; this option
is always required. An InnoDB tablespace supports only a single data
file, whose name must include a .ibd extension. A MySQL Cluster
tablespace supports multiple data files which can have any legal file
names; more data files can be added to a MySQL Cluster tablespace
following its creation by using an ALTER TABLESPACE statement.
*Note*:
ALTER TABLESPACE is not supported by InnoDB.
To place the data file in a location outside of the MySQL data
directory (datadir), include an absolute directory path or a path
relative to the MySQL data directory. If you do not specify a path,
the tablespace is created in the MySQL data directory. An isl file is
created in the MySQL data directory when an InnoDB tablespace is
created outside of the MySQL data directory.
To avoid conflicts with implicitly created file-per-table
tablespaces, creating a general tablespace in a subdirectory under
the MySQL data directory is not supported. Also, when creating a
general tablespace outside of the MySQL data directory, the directory
must exist prior to creating the tablespace.
The file_name, including the path (optional), must be quoted with
single or double quotations marks. File names (not counting any
".ibd" extension for InnoDB files) and directory names must be at
least one byte in length. Zero length file names and directory names
are not supported.
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.
If you do not specify this option, FILE_BLOCK_SIZE defaults to
innodb_page_size. FILE_BLOCK_SIZE is required when you intend to use
the tablespace for storing compressed InnoDB tables
(ROW_FORMAT=COMPRESSED).
If FILE_BLOCK_SIZE is equal innodb_page_size, the tablespace can
contain only tables having an uncompressed row format (COMPACT,
REDUNDANT, or DYNAMIC). The physical page size for tables using
COMPRESSED differs from that of uncompressed tables; this means that
compressed tables and uncompressed tables cannot coexist in the same
tablespace.
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
http://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
http://dev.mysql.com/doc/refman/5.7/en/files-table.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
http://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 The TABLESPACE option may be used with CREATE TABLE or ALTER TABLE to
assign InnoDB table partitions or subpartitions to a general
tablespace, a separate file-per-table tablespace, or the system
tablespace. TABLESPACE option support for table partitions and
subpartitions was added in MySQL 5.7. All partitions must belong to
the same storage engine. For more information, see
http://dev.mysql.com/doc/refman/5.7/en/general-tablespaces.html.
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 a MySQL Cluster tablespace you must also
remove all its data files using one or more ALTER TABLESPACE ... DROP
DATATFILE statements. See
http://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data-object
s.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.
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;
Query OK, 0 rows affected (0.01 sec)
mysql> CREATE TABLE t1 (c1 INT PRIMARY KEY)
-> TABLESPACE ts1
-> ROW_FORMAT=REDUNDANT;
Query OK, 0 rows affected (0.00 sec)
mysql> CREATE TABLE t2 (c1 INT PRIMARY KEY)
-> TABLESPACE ts1
-> ROW_FORMAT=COMPACT;
Query OK, 0 rows affected (0.00 sec)
mysql> CREATE TABLE t3 (c1 INT PRIMARY KEY)
-> TABLESPACE ts1
-> ROW_FORMAT=DYNAMIC;
Query OK, 0 rows affected (0.00 sec)
This example demonstrates creating a general tablespace and adding a
compressed table. The example assumes a default innodb_page_size 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;
Query OK, 0 rows affected (0.01 sec)
mysql> CREATE TABLE t4 (c1 INT PRIMARY KEY)
-> TABLESPACE ts2
-> ROW_FORMAT=COMPRESSED
-> KEY_BLOCK_SIZE=8;
Query OK, 0 rows affected (0.00 sec)
NDB Example
Suppose that you wish to create a MySQL 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, f?K� 3�� |� 3�
���irst_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 MySQL
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
http://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data-objects.
html.
URL: http://dev.mysql.com/doc/refman/5.7/en/create-tablespace.html
� |� 3����
�OE� 4N� 1�
infimum supremum1 o�@
� } "� 6�GRANT
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 http://dev.mysql.com/doc/refman/5.7/en/account-names.html)
auth_option: { # Before MySQL 5.7.6
IDENTIFIED BY 'auth_string'
| IDENTIFIED BY PASSWORD 'hash_string'
| IDENTIFIED WITH auth_plugin
| IDENTIFIED WITH auth_plugin AS 'hash_string'
}
auth_option: { # As of MySQL 5.7.6
IDENTIFIED BY 'auth_string'
| IDENTIFIED BY PASSWORD 'hash_string'
| IDENTIFIED WITH auth_plugin
| IDENTIFIED WITH auth_plugin BY 'auth_string'
| IDENTIFIED WITH auth_plugin AS 'hash_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 use GRANT, you must have the GRANT OPTION privilege, and you must
have the privileges that you are granting. 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
http://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 'mypass';
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 as of MySQL 5.7.6. 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: http://dev.mysql.com/doc/refman/5.7/en/grant.html
http://dev.mysql.com/doc/refman/5.7/en/grant.htmlU �@ � ~ "� 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html@Z��@ � "� 6�IS NOT Syntax:
IS NOT boolean_value
Tests a value against a boolean value, where boolean_value can be TRUE,
FALSE, or UNKNOWN.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlB����@ (� � "� 6�SQRT Syntax:
SQRT(X)
Returns the square root of a nonnegative number X.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html= �@ 0� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html8 ;�@ 8� � "� 6�CREATE INDEX (Syntax:
CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name
[index_type]
ON tbl_name (index_col_name,...)
[index_option]
[algorithm_option | lock_option] ...
index_col_name:
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}
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
http://dev.mysql.com/doc/refman/5.7/en/mysql-indexes.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/create-index.html
http://dev.mysql.com/doc/refman/5.7/en/create-index.html: j�@ @ � "� 6�ALTER DATABASE (Syntax:
ALTER {DATABASE | SCHEMA} [db_name]
alter_specification ...
ALTER {DATABASE | SCHEMA} db_name
UPGRADE DATA DIRECTORY NAME
alter_specification:
[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. To use ALTER DATABASE, you need 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.
National Language Characteristics
The CHARACTER SET clause changes the default database character set.
The COLLATE clause changes the default database collation.
http://dev.mysql.com/doc/refman/5.7/en/charset.html, discusses
character set and collation names.
You can see what character sets and collations are available using,
respectively, the SHOW CHARACTER SET and SHOW COLLATION statements. See
[HELP SHOW CHARACTER SET], and [HELP SHOW COLLATION], for more
information.
If you change the default character set or collation for a database,
stored routines that use the database defaults must be dropped and
recreated so that they use the new defaults. (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].)
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
http://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.6 and
will be removed in a future version of MySQL. 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 a more recent
release.
URL: http://dev.mysql.com/doc/refman/5.7/en/alter-database.html
http://dev.mysql.com/doc/refman/5.7/en/alter-database.htmlC+�ǀ@ H� � "� 6�JSON_ARRAY JSON_ARRAY([val[, val] ...])
Evaluates a (possibly empty) list of values and returns a JSON array
containing those values.
URL: http://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"] |
+---------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.htmlU ـ@ P� � "� 6 GEOMETRYN GeometryN(gc, N)
ST_GeometryN() and GeometryN() are synonyms. For more information, see
the description of ST_GeometryN().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html9#?�@ X� � "� 6 << 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: http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 1 << 2;
-> 4
http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html= (�@ `� � "� 6 #SHOW 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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-table-status.html
http://dev.mysql.com/doc/refman/5.7/en/show-table-status.html<x�@ h � "� 6 0ASCII &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: http://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
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@N��@ pŠ� "� 6 =DIV 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html p&�� c��� �O��6� �E� ;d� :P infimum supremum= ��@ A � "� 6 JSHOW SLAVE STATUS Syntax:
SHOW SLAVE STATUS [NONBLOCKING # Removed in MySQL 5.7.6]
[FOR CHANNEL channel]
This statement provides status information on essential parameters of
the slave threads. It requires either the SUPER or REPLICATION CLIENT
privilege.
Between MySQL 5.7.1 and MySQL 5.7.5, an optional NONBLOCKING clause
could be used. The NONBLOCKING clause caused SHOW SLAVE STATUS, when
run concurrently with STOP SLAVE, to return without waiting for STOP
SLAVE to finish shutting down the slave SQL thread or slave I/O thread
(or both). This option was intended for use in monitoring and other
applications where getting an immediate response from SHOW SLAVE STATUS
was more important than ensuring that it returned the latest data. This
option was removed in MySQL 5.7.6 due to locking changes in replication
administrative statements. As of MySQL 5.7.9 the non-blocking behavior
of SHOW SLAVE STATUS is fixed and the option became unnecessary.
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: root
Master_Port: 13000
Connect_Retry: 60
Master_Log_File: master-bin.000002
Read_Master_Log_Pos: 1307
Relay_Log_File: slave-relay-bin.000003
Relay_Log_Pos: 1508
Relay_Master_Log_File: master-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: Slave has read all relay log; waiting for the slave I/O thread to update it
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:
1 row in set (0.00 sec)
As of MySQL 5.7.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
http://dev.mysql.com/doc/refman/5.7/en/performance-schema-replication-t
ables.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-slave-status.html
http://dev.mysql.com/doc/refman/5.7/en/show-slave-status.htmlD S�@ � "� 6 WGEOMETRY #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].
URL: http://dev.mysql.com/doc/refman/5.7/en/creating-spatial-columns.html
CREATE TABLE geom (g GEOMETRY);
http://dev.mysql.com/doc/refman/5.7/en/creating-spatial-columns.html9%��@ @ � "� 6 d& Syntax:
&
Bitwise AND.
The result is an unsigned 64-bit integer.
URL: http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 29 & 15;
-> 13
http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html@��r�@ ( � "� 6 qASSIGN-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: http://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
http://dev.mysql.com/doc/refman/5.7/en/assignment-operators.html: �@ 0 � � "� 6 ~CONVERT &Syntax:
CONVERT(expr,type), CONVERT(expr USING transcoding_name)
The CONVERT() function takes an expression of any type and produces a
result value of the specified type.
Discussion of CONVERT(expr, type) syntax here also applies to CAST(expr
AS type), which is equivalent.
CONVERT(... USING ...) is standard SQL syntax. The non-USING form of
CONVERT() is ODBC syntax.
CONVERT() with USING 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() without USING and CAST() take an expression and a type value
specifying the result type. These type values are permitted:
o BINARY[(N)]
Produces a string with the BINARY data type. See
http://dev.mysql.com/doc/refman/5.7/en/binary-varbinary.html for a
description of how this affects comparisons. 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.
o CHAR[(N)] [charset_info]
Produces a string with the CHAR data type. 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.
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 default collation for the character
set.
o DATE
Produces a DATE value.
o DATETIME
Produces a DATETIME value.
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).
o JSON (added in MySQL 5.7.8)
Produces a JSON value. For details on the rules for conversion of
values between JSON and other types, see
http://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
http://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 integer value.
o TIME
Produces a TIME value.
o UNSIGNED [INTEGER]
Produces an unsigned integer value.
URL: http://dev.mysql.com/doc/refman/5.7/en/cast-functions.html
http://dev.mysql.com/doc/refman/5.7/en/cast-functions.html2����@ 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: http://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)
http://dev.mysql.com/doc/refman/5.7/en/repeat.htmlI����@ @� � "� 6 �ST_ISVALID ST_IsValid(g)
Checks whether a geometry is valid, as defined by the OGC
specification. ST_IsValid() returns 1 if the argument is a valid
geometry byte string and is geometrically valid, 0 if the argument is
not a valid geometry byte string or is not geometrically valid. If the
argument is NULL, the return value is NULL.
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
error occurs otherwise.
URL: http://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_IsValid(@ls1);
+------------------+
| ST_IsValid(@ls1) |
+------------------+
| 0 |
+------------------+
mysql> SELECT ST_IsValid(@ls2);
+------------------+
| ST_IsValid(@ls2) |
+------------------+
| 1 |
+------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.htmlA ƀ@ Hd � "� 6 �SMALLINT SMALLINT[(M)] [UNSIGNED] [ZEROFILL]
A small integer. The signed range is -32768 to 32767. The unsigned
range is 0 to 65535.
URL: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.htmlA %�@ P� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html<&ȁ@ X� � "� 6 �ORD &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 * 2562) ...
If the leftmost character is not a multibyte character, ORD() returns
the same value as the ASCII() function.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT ORD('2');
-> 50
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlJ ƀ@ `m � "� 6 �ENVELOPE %Envelope(g)
ST_Envelope() and Envelope() are synonyms. For more information, see
the description of ST_Envelope().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlJ .�@ h� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlC:Z�@ p4 � "� 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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT INET_ATON('10.0.5.9');
-> 167773449
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlJ ƀ@ xl � "� 6 �ISSIMPLE %IsSimple(g)
ST_IsSimple() and IsSimple() are synonyms. For more information, see
the description of ST_IsSimple().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html@!`@ �� � "� 6
- BINARY Syntax:
-
Subtraction:
URL: http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 3-5;
-> -2
http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html p-� c��6� �Ϣؗ JgE� ;X� 8v
infimum supremumC ��@ R � "� 6
CURRENT_TIME Syntax:
CURRENT_TIME, CURRENT_TIME([fsp])
CURRENT_TIME and CURRENT_TIME() are synonyms for CURTIME().
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html< y�@ � "� 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
http://dev.mysql.com/doc/refman/5.7/en/spatial-extensions.html).
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-data-formats.html
http://dev.mysql.com/doc/refman/5.7/en/gis-data-formats.htmlH����@ � "� 6
'ST_Y ST_Y(p)
Returns the Y-coordinate value for the Point object p as a
double-precision number.
URL: http://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 |
+--------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html2 ��@ (N � "� 6
4REVOKE
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.
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
http://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 '%'.
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]
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 database.
URL: http://dev.mysql.com/doc/refman/5.7/en/revoke.html
http://dev.mysql.com/doc/refman/5.7/en/revoke.htmlC���@ 0� � "� 6
ALAST_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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlA Հ@ 8s � "� 6
NMEDIUMINT MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL]
A medium-sized integer. The signed range is -8388608 to 8388607. The
unsigned range is 0 to 16777215.
URL: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html@ b�@ @� � "� 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 (OpenSSL or
yaSSL). Permitted values of len range from 1 to 1024. For values
outside that range, RANDOM_BYTES() generates a warning and returns
NULL.
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.
This function is available as of MySQL 5.7.4.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html<6��@ Hf � "� 6
hRTRIM &Syntax:
RTRIM(str)
Returns the string str with trailing space characters removed.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT RTRIM('barbar ');
-> 'barbar'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html3 ݖ@ Pm � "� 6
uEXPLAIN Syntax:
{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). The
following discussion uses the DESCRIBE and EXPLAIN keywords in
accordance with those uses, but the MySQL parser treats them as
completely synonymous.
o http://dev.mysql.com/doc/refman/5.7/en/explain.html#explain-table-str
ucture
o http://dev.mysql.com/doc/refman/5.7/en/explain.html#explain-execution
-plan
Obtaining Table Structure Information
DESCRIBE provides information about the columns in a table:
mysql> DESCRIBE City;
+------------+----------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------+----------+------+-----+---------+----------------+
| Id | int(11) | NO | PRI | NULL | auto_increment |
| Name | char(35) | NO | | | |
| Country | char(3) | NO | UNI | | |
| District | char(20) | YES | MUL | | |
| Population | int(11) | NO | | 0 | |
+------------+----------+------+-----+---------+----------------+
DESCRIBE is a shortcut for SHOW COLUMNS. These statements also display
information for views. The description for SHOW COLUMNS provides more
information about the output columns. See [HELP SHOW COLUMNS].
By default, DESCRIBE displays information about all columns in the
table. col_name, if given, is the name of a column in the table. In
this case, the statement displays information only for the named
column. wild, if given, is a pattern string. It can contain the SQL %
and _ wildcard characters. In this case, the statement displays output
only for the columns with names matching the string. There is no need
to enclose the string within quotation marks unless it contains spaces
or other special characters.
The DESCRIBE statement is provided for compatibility with Oracle.
The SHOW CREATE TABLE, SHOW TABLE STATUS, and SHOW INDEX statements
also provide information about tables. See [HELP SHOW].
Obtaining Execution Plan Information
The EXPLAIN statement provides information about how MySQL executes
statements:
o EXPLAIN works with SELECT, DELETE, INSERT, REPLACE, and UPDATE
statements.
o When EXPLAIN is used with an explainable statement, MySQL displays
information from the optimizer about the statement execution plan.
That is, MySQL explains how it would process the statement, including
information about how tables are joined and in which order. For
information about using EXPLAIN to obtain execution plan information,
see http://dev.mysql.com/doc/refman/5.7/en/explain-output.html.
o When EXPLAIN is used with FOR CONNECTION connection_id rather than an
explainable statement, it displays the execution plan for the
statement executing in the named connection. See
http://dev.mysql.com/doc/refman/5.7/en/explain-for-connection.html.
o For SELECT statements, EXPLAIN produces additional execution plan
information. See
http://dev.mysql.com/doc/refman/5.7/en/explain-extended.html.
*Note*:
In older MySQL releases, extended information was produced using
EXPLAIN EXTENDED. That syntax is still recognized for backward
compatibility but extended output is now enabled by default, so the
EXTENDED keyword is superfluous and deprecated. Its use results in a
warning, and it will be removed from EXPLAIN syntax in a future MySQL
release.
o EXPLAIN is useful for examining queries involving partitioned tables.
See http://dev.mysql.com/doc/refman/5.7/en/partitioning-info.html.
*Note*:
In older MySQL releases, partition information was produced using
EXPLAIN PARTITIONS. That syntax is still recognized for backward
compatibility but partition output is now enabled by default, so the
PARTITIONS keyword is superfluous and deprecated. Its use results in
a warning, and it will be removed from EXPLAIN syntax in a future
MySQL release.
o The FORMAT option can be used to select the output format.
TRADITIONAL presents the output in tabular format. This is the
default if no FORMAT option is present. JSON format displays the
information in JSON format.
With the help of EXPLAIN, you can see where you should add indexes to
tables so that the statement executes faster by using indexes to find
rows. You can also use EXPLAIN to check whether the optimizer joins the
tables in an optimal order. To give a hint to the optimizer to use a
join order corresponding to the order in which the tables are named in
a SELECT statement, begin the statement with SELECT STRAIGHT_JOIN
rather than just SELECT. (See
http://dev.mysql.com/doc/refman/5.7/en/select.html.)
The optimizer trace may sometimes provide information complementary to
that of EXPLAIN. However, the optimizer trace format and content are
subject to change between versions. For details, see MySQL Internals:
Tracing the Optimizer
(http://dev.mysql.com/doc/internals/en/optimizer-tracing.html).
If you have a problem with indexes not being used when you believe that
they should be, run ANALYZE TABLE to update table statistics, such as
cardinality of keys, that can affect the choices the optimizer makes.
See [HELP ANALYZE TABLE].
URL: http://dev.mysql.com/doc/refman/5.7/en/explain.html
http://dev.mysql.com/doc/refman/5.7/en/explain.htmlB[��@ X� � "� 6
�DEGREES Syntax:
DEGREES(X)
Returns the argument X, converted from radians to degrees.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT DEGREES(PI());
-> 180
mysql> SELECT DEGREES(PI() / 2);
-> 90
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html@!��@ `M � "� 6
�- UNARY Syntax:
-
Unary minus. This operator changes the sign of the operand.
URL: http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT - 2;
-> -2
http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html@ [�@ h� � "� 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
http://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. http://dev.mysql.com/doc/refman/5.7/en/charset-national.html.
NVARCHAR is shorthand for NATIONAL VARCHAR.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html<Ҁ&�@ p� � "� 6
�UNHEX &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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html8 W�@ x� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/drop-trigger.html
http://dev.mysql.com/doc/refman/5.7/en/drop-trigger.html p9� cϢؗ Jg^��5 ۉE� 3"� 1y infimum supremum8 ��@ � � "� 6
�RESET MASTER Syntax:
RESET MASTER
Deletes all binary log files listed in the index file, resets the
binary log index file to be empty, and creates a new binary log file.
RESET MASTER also clears the values of the gtid_purged system variable
as well as the global value of the gtid_executed system variable (but
not its session value); that is, executing this statement sets each of
these values to an empty string (''). In MySQL 5.7.5 and later, this
statement also clears the mysql.gtid_executed table (see
http://dev.mysql.com/doc/refman/5.7/en/replication-gtids-concepts.html#
replication-gtids-gtid-executed-table).
This statement is intended to be used only when the master is started
for the first time.
URL: http://dev.mysql.com/doc/refman/5.7/en/reset-master.html
http://dev.mysql.com/doc/refman/5.7/en/reset-master.htmlBq�@ � � "� 6
�PI 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.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT PI();
-> 3.141593
mysql> SELECT PI()+0.000000000000000000;
-> 3.141592653589793116
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC ��@ * � "� 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 indeterminate 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
http://dev.mysql.com/doc/refman/5.7/en/group-by-handling.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html@#]@ ( � "� 6
�/ Syntax:
/
Division:
URL: http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 3/5;
-> 0.60
http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html=V+�@ 0 � "� 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
http://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.
This statement has no effect if the server was not started with the
--log-bin option to enable binary logging.
URL: http://dev.mysql.com/doc/refman/5.7/en/purge-binary-logs.html
PURGE BINARY LOGS TO 'mysql-bin.010';
PURGE BINARY LOGS BEFORE '2008-04-02 22:46:26';
http://dev.mysql.com/doc/refman/5.7/en/purge-binary-logs.html> �@ 8� � "� 6 STDDEV_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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlT %�@ @� � "� 6 ST_TOUCHES ST_Touches(g1, g2)
Returns 1 or 0 to indicate whether g1 spatially touches g2. Two
geometries spatially touch if the interiors of the geometries do not
intersect, but the boundary of one of the geometries intersects either
the boundary or the interior of the other.
As of MySQL 5.7.5, 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlA ��@ H$ � "� 6 SCHEMA Syntax:
SCHEMA()
This function is a synonym for DATABASE().
URL: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
http://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlU �@ P� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html= 0�@ X� � "� 6 8MLINEFROMWKB !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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html=�Ɓ@ `n � "� 6 ESHOW 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
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/show-create-table.html2 ��@ h: � "� 6 RDUAL 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: http://dev.mysql.com/doc/refman/5.7/en/select.html
http://dev.mysql.com/doc/refman/5.7/en/select.html<j�@ p � "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT INSTR('foobarbar', 'bar');
-> 4
mysql> SELECT INSTR('xbar', 'foobar');
-> 0
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@#k@ x, � "� 6 l>= Syntax:
>=
Greater than or equal:
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 >= 2;
-> 1
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlB����@ � � "� 6 yEXP 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlJ �@ �� � "� 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 description of each instantiable geometric class given earlier in
the chapter includes the specific conditions that cause an instance of
that class to be classified as not simple. (See [HELP Geometry
hierarchy].)
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlM ŀ@ �o � "� 6 �POINTN
PointN(ls, N)
ST_PointN() and PointN() are synonyms. For more information, see the
description of ST_PointN().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT OCT(12);
-> '14'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html p%� �7 c^��5 ۉ�# s�E� 9�� 7� infimum supremumC p�@ � "� 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
a 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 master and the slave.
The nondeterministic nature of SYSDATE() also means that indexes cannot
be used for evaluating expressions that refer to it.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html< x�@ � "� 6 �UNINSTALL PLUGIN Syntax:
UNINSTALL PLUGIN plugin_name
This statement removes an installed server plugin. It requires the
DELETE privilege for the mysql.plugin system table. UNINSTALL PLUGIN is
the complement of INSTALL 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
table, so that subsequent server restarts will not load and initialize
the plugin. UNINSTALL PLUGIN does not remove the plugin's shared
library file.
URL: http://dev.mysql.com/doc/refman/5.7/en/uninstall-plugin.html
http://dev.mysql.com/doc/refman/5.7/en/uninstall-plugin.htmlK �@ � � "� 6 �ASBINARY !AsBinary(g), AsWKB(g)
ST_AsBinary(), ST_AsWKB(), AsBinary(), and AsWKB() are synonyms. For
more information, see the description of ST_AsBinary().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html7 ��@ 0P � "� 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 http://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 FULL modifier
is supported such that SHOW FULL TABLES displays a second output
column. Values for the second column are BASE TABLE for a table and
VIEW for a view.
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: http://dev.mysql.com/doc/refman/5.7/en/show-tables.html
http://dev.mysql.com/doc/refman/5.7/en/show-tables.htmlC�@ 8_ � "� 6 �MAKEDATE 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html:����@ @� � "� 6 �BINARY OPERATOR &Syntax:
BINARY expr
The BINARY operator converts the expression to a binary string. A
common use for BINARY is to force a character string comparison to be
done byte by byte rather than character by character, in effect
becoming case sensitive. The BINARY operator also causes trailing
spaces in comparisons to be significant.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/cast-functions.htmlU ��@ HD � "� 6 MBROVERLAPS MBROverlaps(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangles of
the two geometries g1 and g2 overlap. The term spatially overlaps is
used if two geometries intersect and their intersection results in a
geometry of the same dimension but not equal to either of the given
geometries.
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html= �@ P� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlK �@ X� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html9 �@ `� � "� 6 /INSERT SELECT Syntax:
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name,...)]
[(col_name,...)]
SELECT ...
[ ON DUPLICATE KEY UPDATE col_name=expr, ... ]
With INSERT ... SELECT, you can quickly insert many rows into a table
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: http://dev.mysql.com/doc/refman/5.7/en/insert-select.html
http://dev.mysql.com/doc/refman/5.7/en/insert-select.html< �@ h � � "� 6 <CREATE PROCEDURE ( & #�http://dev.mysql.com/doc/refman/5.7/en/create-procedure.html; �@ p � � "� 6 IGET DIAGNOSTICS & fhttp://dev.mysql.com/doc/refman/5.7/en/get-diagnostics.html2 ��@ x% � "� 6 VNOT REGEXP &Syntax:
expr NOT REGEXP pat, expr NOT RLIKE pat
This is the same as NOT (expr REGEXP pat).
URL: http://dev.mysql.com/doc/refman/5.7/en/regexp.html
http://dev.mysql.com/doc/refman/5.7/en/regexp.html1 E�@ �� � "� 6 cLEAVE 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: http://dev.mysql.com/doc/refman/5.7/en/leave.html
http://dev.mysql.com/doc/refman/5.7/en/leave.htmlE<���@ �� � "� 6 pST_GEOHASH ST_GeoHash(longitude, latitude, max_length), ST_GeoHash(point,
max_length)
Returns a geohash string in the connection character set and collation.
The result is NULL if any argument is NULL. An error occurs if any
argument is invalid.
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: http://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 |
+----------------------+-------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.html@ ��@ �5 � "� 6 }NOT IN Syntax:
expr NOT IN (value,...)
This is the same as NOT (expr IN (value,...)).
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlH ��@ �M � "� 6 �X X(p)
ST_X() and X() are synonyms. For more information, see the description
of ST_X().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.htmlAn�@ �� � "� 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: http://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();
http://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlT р@ �� � "� 6 �CROSSES Crosses(g1, g2)
ST_Crosses() and Crosses() are synonyms. For more information, see the
description of ST_Crosses().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlFn���@ �� � "� 6 �ST_UNION ST_Union(g1, g2)
Returns a geometry that represents the point set union of the geometry
values g1 and g2.
URL: http://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)) |
+--------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html> �@ �ȅ � "� 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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html p(�$IR2 c�# s��6� ��
#�����Syntax:
CREATE
[DEFINER = { user | CURRENT_USER }]
PROCEDURE sp_name ([proc_parameter[,...]])
[characteristic ...] routine_body
CREATE
[DEFINER = { user | CURRENT_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 create stored routines. By default, a 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 UDFs
(user-defined functions). See
http://dev.mysql.com/doc/refman/5.7/en/adding-functions.html. A UDF can
be regarded as an external stored function. Stored functions share
their namespace with UDFs. See
http://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. They might also require the SUPER privilege, depending on
the DEFINER value, as described later in this section. If binary
logging is enabled, CREATE FUNCTION might require the SUPER privilege,
as described in
http://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
http://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 IN or INOUT
parameter.
Routine parameters cannot be referenced in statements prepared within
the routine; see
http://dev.mysql.com/doc/refman/5.7/en/stored-program-restrictions.html
.
The following example shows a simple stored procedure that uses an OUT
parameter:
mysql> delimiter //
mysql> CREATE PROCEDURE simpleproc (OUT param1 INT)
-> BEGIN
-> SELECT COUNT(*) INTO param1 FROM t;
-> END//
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> CALL simpleproc(@a);
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @a;
+------+
| @a |
+------+
| 3 |
+------+
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
http://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 the
CHARACTER SET attribute.
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
http://dev.mysql.com/doc/refman/5.7/en/sql-syntax-compound-statements.h
tml.
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). 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).
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
http://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: http://dev.mysql.com/doc/refman/5.7/en/create-procedure.html
��6� ���Ф$ ��
f����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
http://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
http://dev.mysql.com/doc/refman/5.7/en/diagnostics-area.html#diagnostic
s-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 rows 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 rows = ROW_COUNT;
SET result = CONCAT('insert succeeded, row count = ',rows);
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: http://dev.mysql.com/doc/refman/5.7/en/get-diagnostics.html
�Ф$ ���0 �HE� ;4� 9� infimum supremumA��ǂ@ d � "� 6 �->> 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, 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: http://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)
http://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html1 ��@ � � "� 6 �FLUSH Syntax:
FLUSH [NO_WRITE_TO_BINLOG | LOCAL]
flush_option [, flush_option] ...
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 described later.
By default, the server writes FLUSH statements to the binary log so
that they replicate to replication slaves. To suppress logging, specify
the optional NO_WRITE_TO_BINLOG keyword or its alias LOCAL.
*Note*:
FLUSH 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
slave.
Sending a SIGHUP signal to the server causes several flush operations
to occur that are similar to various forms of the FLUSH statement. See
http://dev.mysql.com/doc/refman/5.7/en/server-signal-response.html.
The FLUSH statement causes an implicit commit. See
http://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
The RESET statement is similar to FLUSH. See [HELP RESET], for
information about using the RESET statement with replication.
URL: http://dev.mysql.com/doc/refman/5.7/en/flush.html
http://dev.mysql.com/doc/refman/5.7/en/flush.html5 6�@ � � "� 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
http://dev.mysql.com/doc/refman/5.7/en/stored-programs-defining.html.
A BEGIN ... END block can be labeled. See [HELP labels].
URL: http://dev.mysql.com/doc/refman/5.7/en/begin-end.html
http://dev.mysql.com/doc/refman/5.7/en/begin-end.htmlA܁��@ (+ � "� 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]).
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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: http://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: 2004-08-03 15:29:37
Created: 2004-08-03 15:29:37
Security_type: DEFINER
Comment:
character_set_client: latin1
collation_connection: latin1_swedish_ci
Database Collation: latin1_swedish_ci
http://dev.mysql.com/doc/refman/5.7/en/show-procedure-status.html> <�@ 0� � "� 6 �STDDEV_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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html> �@ 8� � "� 6
SHOW CHARACTER SET Syntax:
SHOW CHARACTER SET
[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
http://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: http://dev.mysql.com/doc/refman/5.7/en/show-character-set.html
http://dev.mysql.com/doc/refman/5.7/en/show-character-set.htmlJ Ӏ@ @{ � "� 6
INTERSECTS Intersects(g1, g2)
MBRIntersects() and Intersects() are synonyms. For more information,
see the description of MBRIntersects().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html0����@ H � "� 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: http://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;
http://dev.mysql.com/doc/refman/5.7/en/loop.html@����@ P0 � "� 6
3GREATEST 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html: �@ X� � "� 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. Using ALTER INSTANCE requires the SUPER
privilege.
The ALTER INSTANCE ROTATE INNODB MASTER KEY statement is used to rotate
the master encryption key used for InnoDB tablespace encryption. A
keyring plugin must be loaded to use this statement. For information
about keyring plugins, see
http://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
http://dev.mysql.com/doc/refman/5.7/en/innodb-tablespace-encryption.htm
l. For information about keyring plugins, see
http://dev.mysql.com/doc/refman/5.7/en/keyring.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/alter-instance.html
http://dev.mysql.com/doc/refman/5.7/en/alter-instance.htmlT �@ `� � "� 6
MST_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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html> �@ h� � "� 6
ZBIT_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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlC/��@ pd � "� 6
gSECOND Syntax:
SECOND(time)
Returns the second for time, in the range 0 to 59.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT SECOND('10:05:03');
-> 3
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlU�� �@ xb � "� 6
tMBRCONTAINS 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.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 |
+----------------------+--------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.htmlC ݀@ �| � "� 6
�RELEASE_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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlBYv@ �Ơ � "� 6
�COT Syntax:
COT(X)
Returns the cotangent of X.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT COT(12);
-> -1.5726734063977
mysql> SELECT COT(0);
-> NULL
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html p1�$l: c�0 �H�.� ���� ( ""�E� ?|����Z � " Qinfimum supremum@ 3*& �@ J- BINARY �@ -b- UNARY �@ ( J->> �@ 0-/ �@ 8 J<< �@ @4R<= 3@ H >= �@ P$lABS :@ X�ALTER DATABASE �@ `
�ALTER INSTANCE �@ h&�ALTER VIEW g@ p4�ANY_VALUE �@ x JASBINARY �@ �6ASCII �@ �3�ASSIGN-EQUAL �@ � JASYMMETRIC_DECRYPT @ � JASYMMETRIC_DERIVE �@ �-�ASYMMETRIC_ENCRYPT @ �
�BEGIN END �@ �0�BETWEEN AND \@ � JBINARY 0@ �
BINARY OPERATOR �@ � @BIT_LENGTH Y@ ��BIT_XOR �@ � JBLOB DATA TYPE 1@ � �BOOLEAN H@ � FCACHE INDEX C@ � JCASE OPERATOR (@ � �CASE STATEMENT 6@ JCHAR FUNCTION
@1�CHARACTER_LENGTH w@ ,CHAR_LENGTH R@ RCLOSE %@ JCOMPRESS D@(/�CONCAT @ 0
�CONNECTION_ID "@ 8-CONTAINS @@�CONVERT �@H JCREATE FUNCTION UDF @@ P#�CREATE INDEX �@ X �CREATE PROCEDURE �@ ` JCREATE TABLESPACE y@h% CREATE TRIGGER @ p%JCREATE_ASYMMETRIC_PUB_KEY B@ x
CROSSES �@ � 8CURRENT_TIME �@�)VCURRENT_USER 2@ � DATE S@�.�DEC d@ � JDEGREES �@�$�DELETE #@ ��DISJOINT p@ �*4CRC32 �@ �%�DECLARE VARIABLE �@ �
BIT_OR �@ � �DAYOFMONTH �@ ��ALTER LOGFILE GROUP �@�>CREATE_DIGEST �@ ���ALTER FUNCTION �@ ��DEALLOCATE PREPARE �@ �*COS �@ .DATE FUNCTION �@ ! �@� DECLARE HANDLER �@ ��CURRENT_DATE �@ �CALL @ (�jBENCHMARK @ 0% CONVERT_TZ @8 �CAST "@ @�BAVG %@ H��ALTER EVENT 6@ P�DATE_SUB 7@ X�DATEDIFF <@ `� DECLARE CURSOR A@ h�BLOB F@ p�AES_ENCRYPT P@ x�+ Q@ �CEILING U@ �pCREATE VIEW Y@ �" ALTER TABLE b@ ��BCHAR BYTE c@ ��R> e@ ��CONSTRAINT i@ �#�!= t@ ��BCOLLATION z@ �6COALESCE {@�6INSTR �@ � $INTERSECTS �@ ��IS NOT @ � JISCLOSED @� �ISNULL .@ � JISSIMPLE �@ ��IS_IPV4 ;@ JITERATE P@ JJOIN @ �JSON_ARRAY �@ JJSON_EXTRACT I@ �JSON_INSERT l@( JJSON_SEARCH $@ 0 JJSON_TYPE U@ 8VJSON_UNQUOTE m@ @ JKILL o@H�LAST_DAY �@ P JLEAVE �@ XxLEFT ^@ ` JLOCATE j@h JLOCK @ p LONGTEXT n@ x�BIT_AND �@ ��COT �@ ���LOAD_FILE �@ ��pDATE_FORMAT �@ ��ZIS NULL �@ ��,ALTER SERVER �@��"DATE_ADD �@ ���JSON_VALID �@ �
�LIKE �@ ��4>> �@ ��BINLOG @ ��BDISTANCE �@��CHECKSUM TABLE �@ �,INTERIORRINGN �@ �
�IS_IPV4_COMPAT �@ ��nCREATE FUNCTION �@ � �ADDDATE �@ ��CHECK TABLE @ �\BIN @ �jCHAR
@�COUNT DISTINCT @ PINTERVAL
@ (�PALTER USER /@ 0��ALTER PROCEDURE @ 8�4BIT_COUNT @ @�fACOS @ H�ISOLATION @ P�~BUFFER @ X�JSON_OBJECT @ `��IS @ h��DIMENSION I@ p�CREATE TABLE $@ x��CREATE SERVER &@ ��CURDATE *@ ��JSON_QUOTE ,@ ��@DATABASE -@ �zANALYZE TABLE f@ �ATAN 1@ �
LN 3@��0AES_DECRYPT 7@ ��COERCIBILITY 8@ �PINT 9@ �CENTROID M@ ��JSON_REMOVE <@ ��ATAN2 @ ��CURRENT_TIMESTAMP C@ ��DAYOFWEEK T@ ��&DATETIME G@ ���CHANGE REPLICATION FILTER H@ ��INTEGER I@ ��-> �@ �2< �@ ~DAY U@ ��LINESTRING W@ (ܼCREATE LOGFILE GROUP Y@0�lLINEFROMTEXT ^@ 8�ADDTIME _@ @�2DES_ENCRYPT 0@ H�rCREATE_ASYMMETRIC_PRIV_KEY j@ P�LEAST h@ X��= i@ `�IS_IPV4_MAPPED k@ h�hCREATE USER l@ p��LCASE n@ x��CREATE_DH_PARAMETERS o@ ��^IS NOT NULL p@ ��BCREATE EVENT r@ �ASYMMETRIC_SIGN 9@��* v@ ���DES_DECRYPT y@ ��~AUTO_INCREMENT �@��(DAYNAME x@ ��COUNT }@ �(JSON_ARRAY_APPEND ~@ ��CEIL 1@ ��DDEFAULT �@ ��DECODE �@ �~JSON_ARRAY_INSERT �@ ��<=> �@ ��*BIT J@ ��BIGINT �@ �CURTIME �@ �dJSON_MERGE �@ �LOAD XML �@ �2CONV �@ ASSIGN-VALUE �@ (�dAREA �@ 0�CONVEXHULL �@ 8�DJSON_KEYS �@ @�ALTER TABLESPACE k@ H�CREATE DATABASE �@ PИCONCAT_WS �@ X�<ASIN �@ `�AND @ hΒCHARSET �@ p�<ASYMMETRIC_VERIFY �@ x��JSON_CONTAINS �@ ���DAYOFYEAR �@ ��*% �@ �ȀASTEXT �@ ��DECLARE CONDITION �@��CHANGE MASTER TO �@ ��lDECIMAL �@ � JVARCHAR �@ � JVARIANCE @ � JWITHIN @ � JWKT DEFINITION �@ � JX �@ � XOR | p=|<T;,:8�7�6�5d4<31�0�/�.t-L,$*� p l/� D �� p<��4�!�B � �%� z
�#x t=2pL$��h��b+F�\3� c�.� ""�9��o ( ' " )E� ?|��,�,$ � " infimum supremum@ JLOOP �@ JLOWER @ �LPAD q@ (+�MAKEDATE �@ 076MAX ?@ 8 JMBREQUAL t@ @ JMBREQUALS �@ H JMBRINTERSECTS ~@ P&�MBROVERLAPS �@ X6MEDIUMINT �@ `-bMID !@ h6�MINUTE @ p JMLINEFROMWKB �@ x JMOD J@ � nMONTH @ �"fMPOLYFROMWKB O@ �RMULTIPOLYGON ]@ � JNOT IN �@ � JNOT LIKE =@ � nNOT REGEXP �@ �)�OCT �@ � JOLD_PASSWORD W@ �4OPEN @ � JORD �@ �"fOVERLAPS r@ �0�PI �@ �'�POINTN �@ � JPOLYFROMWKB <@ �0�POLYGON @ � JPREPARE @ JPROCEDURE ANALYSE u@0�PURGE BINARY LOGS �@ JRAND b@ JRANDOM_BYTES �@ BREGEXP @(:RENAME TABLE G@ 0&(REPEAT LOOP �@8/�REPLACE FUNCTION &@ @(xRESET MASTER �@H JREVERSE -@ P�REVOKE �@ X JRPAD c@ ` �RTRIM �@hSCHEMA �@ p0FSEC_TO_TIME i@ x JSET DATA TYPE a@ �)�SET GLOBAL SQL_SLAVE_SKIP_COUNTER s@� JSHOW BINARY LOGS @ � JSHOW BINLOG EVENTS N@ �,�SHOW CHARACTER SET �@ � JSHOW CREATE PROCEDURE
@� JSHOW CREATE TABLE �@ � TSHOW CREATE TRIGGER @��SHOW DATABASES h@�'SHOW EVENTS k@�+�SHOW MASTER STATUS )@ ���SHOW PLUGINS @ ��MONTHNAME �@ �<NUMGEOMETRIES �@ ��HMPOLYFROMTEXT �@ �pRENAME USER �@ �
POW �@ "�NOW �@ $�SHOW ENGINES �@
�SHOW CREATE DATABASE �@ ,SHOW FUNCTION STATUS @ ��LTRIM @ (�MBRDISJOINT @ 0��SHOW @ 8NAME_CONST @ @��RELEASE_LOCK @ H!�SHA1 E@ P�>MPOINTFROMWKB a@ X"fST_GEOHASH �@ ` JST_GEOMCOLLFROMWKB @h JST_GEOMETRYN @ p JST_GEOMETRYTYPE K@ x JST_GEOMFROMTEXT z@ � JST_INTERSECTS @� JST_ISCLOSED _@ � JST_ISEMPTY �@ � JST_ISSIMPLE �@ � JST_ISVALID �@� JST_LINEFROMWKB �@ �0ST_LONGFROMGEOHASH f@ �"�ST_MLINEFROMWKB �@ �#�ST_MPOLYFROMWKB �@� nST_POINTN @ � JST_SIMPLIFY 7@ � ST_STARTPOINT /@ � JST_TOUCHES �@��ST_UNION �@ �
ST_Y �@ �"�SYSDATE �@ JTIMESTAMP A@!�TIMESTAMPDIFF +@ �TO_SECONDS *@ JUCASE M@ JUNHEX �@( JUNINSTALL PLUGIN �@ 0BUPDATE 5@8
LUSE '@ @ JVALIDATE_PASSWORD_STRENGTH @H JVARCHAR �@ P �VARIANCE @ X JWITHIN @` JWKT DEFINITION �@ h JX �@ p~XOR |@ x�6SECOND �@ � �MBRCONTAINS �@ ��&RELEASE_ALL_LOCKS �@ ��SHOW CREATE EVENT �@ ��OR �@ � nPOINTFROMTEXT �@ �YEAR �@ �
RESIGNAL �@ ��MBRCOVERS �@ ��ST_NUMPOINTS �@ �TIME FUNCTION �@ ��jST_ENVELOPE �@ ��MULTIPOINT �@ ��TRUE FALSE �@ �&MBRWITHIN �@ �jSESSION_USER �@ ��RSHOW CREATE FUNCTION �@ :QUOTE &@ ��Y �@ NUMINTERIORRINGS �@ �UTC_TIME �@ �ST_POLYFROMTEXT �@ (�XSHOW ENGINE @ 0PERIOD_ADD @ 8tRIGHT @ @�>MULTILINESTRING @ H��NOT BETWEEN �@ P�MPOINTFROMTEXT @X�HSUBSTR @ `�nSHOW CREATE VIEW @ h�ST_POINTFROMWKB @ p�ST_MAKEENVELOPE @ x��ST_WITHIN @ ���MBRTOUCHES �@ ���PASSWORD G@ ��WAIT_FOR_EXECUTED_GTID_SET @ ��SAVEPOINT ]@ ��TINYBLOB @ ���USER @ �VREPAIR TABLE @ � �MERGE !@ ���SHOW CREATE USER "@ �ݚRADIANS y@ ���MICROSECOND %@ �vST_DISTANCE_SPHERE '@ ���ST_POLYFROMWKB (@ �.MAKETIME )@��SET PASSWORD +@ ��"POINTFROMWKB /@ ڶPOWER 0@ \SHOW GRANTS �@��SET CHARACTER SET 4@ ܼRETURN 5@ �SET SQL_LOG_BIN 6@ (�JREPEAT FUNCTION �@ 0�fPOLYFROMTEXT -@ 8�`OCTET_LENGTH N@ @MAKE_SET ?@ H��MIN A@ P�"REPLACE B@ X�*ST_SYMDIFFERENCE D@ `�|VAR_SAMP F@h�SHOW COLUMNS J@ pbTINYINT K@ xMASTER_POS_WAIT L@ � �^ M@ ���WEEK O@ ���ST_VALIDATE Q@ ��UPDATEXML R@ ��RESET SLAVE S@ ��pST_POINTFROMGEOHASH T@ ��tUUID V@ �۔SHOW INDEX �@ ��(NULLIF Z@ � �ROUND [@ ��
PERIOD_DIFF $@ ��TIMEDIFF ]@ ��nUPPER `@ �̌MEDIUMBLOB a@ ��PSHA2 c@ ��(SHOW FUNCTION CODE e@ ذSHOW ERRORS f@ ��SET NAMES g@ ��ST_GEOMCOLLFROMTEXT j@ �*POINT m@ �MATCH AGAINST q@ (�nMBR DEFINITION s@ 0�jMEDIUMTEXT q@ 8ذPOSITION +@@�TO_BASE64 x@ H��QUARTER (@ PɨMLINEFROMTEXT @ X�"TINYTEXT �@ `�FOPTIMIZE TABLE �@ h�NRESET �@ p�vSHOW COLLATION r@ x�SET �@��PST_MPOINTFROMTEXT �@ ��ZSHOW OPEN TABLES �@ �ɨNUMPOINTS �@ ��ST_NUMINTERIORRINGS �@ ��ZMD5 �@ ���SELECT @ ���TIME_FORMAT �@ ��VAR_POP �@ ��TEXT �@ � ~ �@ ��jROW_COUNT �@ ��MBRCOVEREDBY � p " D � 9��(��<
pd�<1�-�.� � � 0
� � tL�$F������\ c9��o " )-p�� ��E� ;� 8� infimum supremum=Ӄr�@ � � "� 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: http://dev.mysql.com/doc/refman/5.7/en/show-create-event.html
mysql> SHOW CREATE EVENT test.e_daily\G
*************************** 1. row ***************************
Event: e_daily
sql_mode:
time_zone: SYSTEM
Create Event: CREATE 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: latin1
collation_connection: latin1_swedish_ci
Database Collation: latin1_swedish_ci
http://dev.mysql.com/doc/refman/5.7/en/show-create-event.html=��G�@ � � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/logical-operators.html<[�@ � � "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> UPDATE t
SET blob_col=LOAD_FILE('/tmp/picture')
WHERE id=1;
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html= ׀@ (r � "� 6
�POINTFROMTEXT PointFromText(wkt[, srid])
ST_PointFromText() and PointFromText() are synonyms. For more
information, see the description of ST_PointFromText().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.htmlCQ���@ 0� � "� 6
�DATE_FORMAT Syntax:
DATE_FORMAT(date,format)
Formats the date value according to the format string.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlC2��@ 8� � "� 6
�YEAR Syntax:
YEAR(date)
Returns the year for date, in the range 1000 to 9999, or 0 for the
"zero" date.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT YEAR('1987-01-01');
-> 1987
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html@Ex@ @Z � "� 6
�IS NULL Syntax:
IS NULL
Tests whether a value is NULL.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html8'w�@ H3 � "� 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: http://dev.mysql.com/doc/refman/5.7/en/alter-server.html
ALTER SERVER s OPTIONS (USER 'sally');
http://dev.mysql.com/doc/refman/5.7/en/alter-server.html4 A�@ P
� � "� 6RESIGNAL 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 special 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
http://dev.mysql.com/doc/refman/5.7/en/diagnostics-area.html.
For condition_value and signal_information_item, the definitions and
rules are the same for RESIGNAL as for SIGNAL. For example, the
condition_value can be an SQLSTATE value, and the value can indicate
errors, warnings, or "not found." For additional information, see [HELP
SIGNAL].
The RESIGNAL statement takes condition_value and SET clauses, both of
which are optional. This leads to several possible uses:
o RESIGNAL alone:
RESIGNAL;
o RESIGNAL with new signal information:
RESIGNAL SET signal_information_item [, signal_information_item] ...;
o RESIGNAL with a condition value and possibly new signal information:
RESIGNAL condition_value
[SET signal_information_item [, signal_information_item] ...];
URL: http://dev.mysql.com/doc/refman/5.7/en/resignal.html
http://dev.mysql.com/doc/refman/5.7/en/resignal.htmlU y�@ X, � "� 6MBRCOVERS 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 and information about argument handling.
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.htmlM!���@ `s � "� 6 ST_NUMPOINTS
ST_NumPoints(ls)
Returns the number of Point objects in the LineString value ls.
URL: http://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 |
+------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlC����@ h� � "� 6*TIME FUNCTION Syntax:
TIME(expr)
Extracts the time part of the time or datetime expression expr and
returns it as a string.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlCU���@ p� � "� 67DATE_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 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT '2008-12-31 23:59:59' + INTERVAL 1 SECOND;
-> '2009-01-01 00:00:00'
mysql> SELECT INTERVAL 1 DAY + '2008-12-31';
-> '2009-01-01'
mysql> SELECT '2005-01-01' - INTERVAL 1 SECOND;
-> '2004-12-31 23:59:59'
mysql> SELECT DATE_ADD('2000-12-31 23:59:59',
-> INTERVAL 1 SECOND);
-> '2001-01-01 00:00:00'
mysql> SELECT DATE_ADD('2010-12-31 23:59:59',
-> INTERVAL 1 DAY);
-> '2011-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('2005-01-01 00:00:00',
-> INTERVAL '1 1:1:1' DAY_SECOND);
-> '2004-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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlDׁȀ@ x@ � "� 6DJSON_VALID JSON_VALID(val)
Returns 0 or 1 to indicate whether a value is a valid JSON document.
Returns NULL if the argument is NULL.
URL: http://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 |
+---------------------+-----------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.htmlJ n�@ � � "� 6QST_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)) |
+----------------------------------------------------------------+
As of MySQL 5.7.6, 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: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlGej�@ �Ǿ � "� 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.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html p&}� � c-p�� ���ɣ� DpE� 2̀ 1O infimum supremumH ��@ R � "� 6kMULTIPOINT MultiPoint(pt1, pt2, ...)
Constructs a MultiPoint value using Point or WKB Point arguments.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html9#@�@ � � "� 6x>> 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: http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 4 >> 2;
-> 1
http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html1 �@ � � "� 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/fetch.html
http://dev.mysql.com/doc/refman/5.7/en/fetch.html< ��@ (� � "� 6�TRUE 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: http://dev.mysql.com/doc/refman/5.7/en/boolean-literals.html
http://dev.mysql.com/doc/refman/5.7/en/boolean-literals.htmlU�� �@ 0k � "� 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.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 |
+--------------------+--------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.htmlA ��@ 8' � "� 6�SESSION_USER Syntax:
SESSION_USER()
SESSION_USER() is a synonym for USER().
URL: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html@ ߀@ @| � "� 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: http://dev.mysql.com/doc/refman/5.7/en/show-create-function.html
http://dev.mysql.com/doc/refman/5.7/en/show-create-function.htmlT Հ@ H� � "� 6�DISTANCE Distance(g1, g2)
ST_Distance() and Distance() are synonyms. For more information, see
the description of ST_Distance().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlC ��@ P2 � "� 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 the date,
time, or datetime value extracted from str is illegal, 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlH ��@ XM � "� 6�Y Y(p)
ST_Y() and Y() are synonyms. For more information, see the description
of ST_Y().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.html: ��@ `� � "� 6�CHECKSUM TABLE Syntax:
CHECKSUM TABLE tbl_name [, tbl_name] ... [QUICK | EXTENDED]
CHECKSUM TABLE reports a checksum for the contents of a table. During
the checksum operation, the table is locked with a read lock for InnoDB
and MyISAM. 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.
Performance Considerations
By default, the entire table is read row by row and the checksum is
calculated. For large tables, this could take a long time, thus you
would only perform this operation occasionally. This row-by-row
calculation is what you get with the EXTENDED clause, with InnoDB and
all other storage engines other than MyISAM, and with MyISAM tables not
created with the CHECKSUM=1 clause.
For MyISAM tables created with the CHECKSUM=1 clause, CHECKSUM TABLE or
CHECKSUM TABLE ... QUICK returns the "live" table checksum that can be
returned very fast. If the table does not meet all these conditions,
the QUICK method returns NULL. See [HELP CREATE TABLE] for the syntax
of the CHECKSUM clause.
For a nonexistent table, CHECKSUM TABLE returns NULL and generates a
warning.
The checksum value depends on the table row format. If the row format
changes, the checksum also changes. For example, the storage format for
temporal types such as TIME, DATETIME, and TIMESTAMP changed in MySQL
5.6 prior to MySQL 5.6.5, so if a 5.5 table is upgraded to MySQL 5.6,
the checksum value may change.
URL: http://dev.mysql.com/doc/refman/5.7/en/checksum-table.html
http://dev.mysql.com/doc/refman/5.7/en/checksum-table.htmlJ �@ h� � "� 6�NUMINTERIORRINGS NumInteriorRings(poly)
ST_NumInteriorRings() and NumInteriorRings() are synonyms. For more
information, see the description of ST_NumInteriorRings().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlJ �@ p� � "� 6INTERIORRINGN InteriorRingN(poly, N)
ST_InteriorRingN() and InteriorRingN() are synonyms. For more
information, see the description of ST_InteriorRingN().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlCO��@ x� � "� 6UTC_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 a 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlC��e�@ �� � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html9 L�@ �� � "� 6.DROP FUNCTION (The DROP FUNCTION statement is used to drop stored functions and
user-defined functions (UDFs):
o For information about dropping stored functions, see [HELP DROP
PROCEDURE].
o For information about dropping user-defined functions, see [HELP DROP
FUNCTION UDF].
URL: http://dev.mysql.com/doc/refman/5.7/en/drop-function.html
http://dev.mysql.com/doc/refman/5.7/en/drop-function.html= I�@ �� � "� 6;ST_POLYFROMTEXT ST_PolyFromText(wkt[, srid]), ST_PolygonFromText(wkt[, srid])
Constructs a Polygon value using its WKT representation and SRID.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html> ;�@ �� "� 6HSTDDEV Syntax:
STDDEV(expr)
Returns the population standard deviation of expr. This function is
provided for compatibility with Oracle. The standard SQL function
STDDEV_POP() can be used instead.
If there are no matching rows, STDDEV() returns NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlC6��@ �� "� 6UPERIOD_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 that the period argument P is not a
date value.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT PERIOD_ADD(200801,2);
-> 200803
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html<7��@ ��! "� 6bRIGHT &Syntax:
RIGHT(str,len)
Returns the rightmost len characters from the string str, or NULL if
any argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT RIGHT('foobarbar', 4);
-> 'rbar'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html p)�!�x c�ɣ� Dp��� z�E� 6�� 4� infimum supremum; Q�@
� "� 6oDROP 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,
beginning with MySQL 5.7.6.
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;
Query OK, 0 rows affected (0.01 sec)
mysql> CREATE TABLE t1 (c1 INT PRIMARY KEY)
-> TABLESPACE ts10
-> ENGINE=INNODB;
Query OK, 0 rows affected (0.02 sec)
mysql> DROP TABLE t1;
Query OK, 0 rows affected (0.01 sec)
mysql> DROP TABLESPACE ts1;
Query OK, 0 rows affected (0.01 sec)
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: http://dev.mysql.com/doc/refman/5.7/en/drop-tablespace.html
http://dev.mysql.com/doc/refman/5.7/en/drop-tablespace.html7 ��@ = "� 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. CHECK TABLE works for
InnoDB, MyISAM, ARCHIVE, and CSV tables. For MyISAM tables, the key
statistics are updated as well.
Before running CHECK TABLE on InnoDB tables, see
http://dev.mysql.com/doc/refman/5.7/en/check-table.html#check-table-inn
odb.
To check a table, you must have some privilege for it.
CHECK TABLE can also check views for problems, such as tables that are
referenced in the view definition that no longer exist.
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
http://dev.mysql.com/doc/refman/5.7/en/partitioning-maintenance.html.
In MySQL 5.7.1, gtid_next must be set to AUTOMATIC before issuing this
statement. This restriction does not apply in MySQL 5.7.2 or later.
(Bug #16062608, Bug #16715809, Bug #69045)
CHECK TABLE ignores generated virtual columns that are not indexed.
URL: http://dev.mysql.com/doc/refman/5.7/en/check-table.html
http://dev.mysql.com/doc/refman/5.7/en/check-table.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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT BIN(12);
-> '1100'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlH ��@ (f "� 6�MULTILINESTRING MultiLineString(ls1, ls2, ...)
Constructs a MultiLineString value using LineString or WKB LineString
arguments.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html@ J�@ 0� "� 6�SHOW RELAYLOG EVENTS Syntax:
SHOW RELAYLOG EVENTS
[IN 'log_name'] [FROM pos] [LIMIT [offset,] row_count]
Shows the events in the relay log of a replication slave. If you do not
specify 'log_name', the first relay log is displayed. This statement
has no effect on the master.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-relaylog-events.html
http://dev.mysql.com/doc/refman/5.7/en/show-relaylog-events.html= ,�@ 8� "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html< ̀@ @f "� 6�SUBSTR &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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@ �@ H}
"� 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html>4�@ P� "� 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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
mysql> SELECT COUNT(DISTINCT results) FROM student;
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html< ��@ XN "� 6�SHOW CREATE VIEW Syntax:
SHOW CREATE VIEW view_name
This statement shows the CREATE VIEW statement that creates the named
view.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-create-view.html
http://dev.mysql.com/doc/refman/5.7/en/show-create-view.html@��V�@ `�
"� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlC9��@ hf "� 6�FROM_DAYS Syntax:
FROM_DAYS(N)
Given a day number N, returns a DATE value.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT FROM_DAYS(730669);
-> '2007-07-03'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html; ��@ pC "� 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
http://dev.mysql.com/doc/refman/5.7/en/stored-routines-privileges.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/alter-procedure.html
http://dev.mysql.com/doc/refman/5.7/en/alter-procedure.html9Cр@ x� "� 6BIT_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: http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT BIT_COUNT(29), BIT_COUNT(b'101010');
-> 4, 3
http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html= ܀@ �w "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlIo��@ �/ "� 62ST_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 error occurs otherwise.
If any argument is not a valid geometry byte string, or if any
coordinate value of the two points is infinite (that is, NaN), an
ER_GIS_INVALID_DATA error occurs.
URL: http://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)) |
+----------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.htmlT �@ �� "� 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlB��̀@ ��� "� 6LACOS 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html p$�^ c��� z��%�P �fE� :�� 5< infimum supremum; ��@ C "� 6YISOLATION Syntax:
SET [GLOBAL | SESSION] TRANSACTION
transaction_characteristic [, transaction_characteristic] ...
transaction_characteristic:
ISOLATION LEVEL level
| READ WRITE
| READ ONLY
level:
REPEATABLE READ
| READ COMMITTED
| READ UNCOMMITTED
| SERIALIZABLE
This statement specifies transaction characteristics. It takes a list
of one or more characteristic values separated by commas. These
characteristics set the transaction isolation level or access mode. The
isolation level is used for operations on InnoDB tables. The access
mode may be specified as to 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.
Scope of Transaction Characteristics
You can set transaction characteristics globally, for the current
session, or for the next transaction:
o With the GLOBAL keyword, the statement applies globally for all
subsequent sessions. Existing sessions are unaffected.
o With the SESSION keyword, the statement applies to all subsequent
transactions performed within the current session.
o Without any SESSION or GLOBAL keyword, the statement applies to the
next (not started) transaction performed within the current session.
Subsequent transactions revert to using the SESSION isolation level.
A global change to transaction characteristics requires the SUPER
privilege. Any session is free to change its session characteristics
(even in the middle of a transaction), or the characteristics for its
next transaction.
SET TRANSACTION without GLOBAL or SESSION is not permitted while there
is an active transaction:
mysql> START TRANSACTION;
Query OK, 0 rows affected (0.02 sec)
mysql> SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
ERROR 1568 (25001): Transaction characteristics can't be changed
while a transaction is in progress
To set the global default isolation level at server startup, use the
--transaction-isolation=level option to mysqld on the command line or
in an option file. Values of level for this option use dashes rather
than spaces, so the permissible values are READ-UNCOMMITTED,
READ-COMMITTED, REPEATABLE-READ, or SERIALIZABLE. For example, to set
the default isolation level to REPEATABLE READ, use these lines in the
[mysqld] section of an option file:
[mysqld]
transaction-isolation = REPEATABLE-READ
It is possible to check or set the global and session transaction
isolation levels at runtime by using the tx_isolation system variable:
SELECT @@GLOBAL.tx_isolation, @@tx_isolation;
SET GLOBAL tx_isolation='REPEATABLE-READ';
SET SESSION tx_isolation='SERIALIZABLE';
Similarly, to set the transaction access mode at server startup or at
runtime, use the --transaction-read-only option or tx_read_only system
variable. By default, these are OFF (the mode is read/write) but can be
set to ON for a default mode of read only.
Setting the global or session value of tx_isolation or tx_read_only is
equivalent to setting the isolation level or access mode with SET
GLOBAL TRANSACTION or SET SESSION TRANSACTION.
Transaction Isolation Levels
For information about transaction isolation levels, see
http://dev.mysql.com/doc/refman/5.7/en/innodb-transaction-isolation-lev
els.html.
Transaction Access Mode
The transaction access mode may be specified with SET TRANSACTION. By
default, a transaction takes place in read/write mode, with both reads
and writes permitted to tables used in the transaction. This mode may
be specified explicitly using an access mode of READ WRITE.
If the transaction access mode is set to READ ONLY, changes to tables
are prohibited. This may enable storage engines to make performance
improvements that are possible when writes are not permitted.
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.
The READ WRITE and READ ONLY access modes also may be specified for an
individual transaction using the START TRANSACTION statement.
URL: http://dev.mysql.com/doc/refman/5.7/en/set-transaction.html
http://dev.mysql.com/doc/refman/5.7/en/set-transaction.htmlBe��@ � "� 6fSIN Syntax:
SIN(X)
Returns the sine of X, where X is given in radians.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT SIN(PI());
-> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
-> 0
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlF$�ӈ@
� "� 6sST_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. For
an invalid geometry argument, an 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
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.
As of MySQL 5.7.7, 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 error occurs.
URL: http://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)) |
+---------------------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlF �@ (� "� 6�BUFFER Buffer(g, d[, strategy1[, strategy2[, strategy3]]])
ST_Buffer() and Buffer() are synonyms. For more information, see the
description of ST_Buffer().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlC�&�@ 0� "� 6�JSON_OBJECT 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: http://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"} |
+-----------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.html: (�@ 8� "� 6�WAIT_FOR_EXECUTED_GTID_SET Syntax:
WAIT_FOR_EXECUTED_GTID_SET(gtid_set[, timeout])
Introduced in MySQL 5.7.5, WAIT_FOR_EXECUTED_GTID_SET() is similar to
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() in that it waits until a server has
executed all of the transactions whose global transaction identifiers
are contained in gtid_set, or until timeout seconds have elapsed,
whichever occurs first. Unlike WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS(),
WAIT_FOR_EXECUTED_GTID_SET() does not take into account whether the
slave is running or not, and an error is returned if GTID-based
replication is not enabled.
In addition, WAIT_FOR_EXECUTED_GTID_SET() returns only the state of the
query, where 0 represents success, 1 represents timeout, and any other
failures return the error message.
URL: http://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html@I��@ @� "� 6�IS Syntax:
IS boolean_value
Tests a value against a boolean value, where boolean_value can be TRUE,
FALSE, or UNKNOWN.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlC���@ Hd "� 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlJ�L�@ P "� 6�ST_CENTROID ST_Centroid(mpoly)
Returns the mathematical centroid for the MultiPolygon value mpoly as a
Point. The result is not guaranteed to be on the MultiPolygon.
As of MySQL 5.7.5, 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: http://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) |
+------------------------+--------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.htmlA4��@ `� "� 6�USER Syntax:
USER()
Returns the current MySQL user name and host name as a string in the
utf8 character set.
URL: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT USER();
-> 'davida@localhost'
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html8 Ƅ@ h�4 "� 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. By default, it has the same effect as myisamchk --recover
tbl_name. REPAIR TABLE works for MyISAM, ARCHIVE, and CSV tables. See
http://dev.mysql.com/doc/refman/5.7/en/myisam-storage-engine.html
http://dev.mysql.com/doc/refman/5.7/en/archive-storage-engine.html, and
http://dev.mysql.com/doc/refman/5.7/en/csv-storage-engine.html. This
statement does not work with views.
This statement requires SELECT and INSERT privileges for the table.
REPAIR TABLE is supported for partitioned tables. However, the USE_FRM
option cannot be used with this statement on a partitioned table.
In MySQL 5.7.1, gtid_next must be set to AUTOMATIC before issuing this
statement. This restriction does not apply in MySQL 5.7.2 or later.
(Bug #16062608, Bug #16715809, Bug #69045)
You can use ALTER TABLE ... REPAIR PARTITION to repair one or more
partitions; for more information, see [HELP ALTER TABLE], and
http://dev.mysql.com/doc/refman/5.7/en/partitioning-maintenance.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/repair-table.html
http://dev.mysql.com/doc/refman/5.7/en/repair-table.html p*� � c�%�P �f 8�? �hE� ;�� 9�
infimum supremum@ ���@ ] ! "� 6�MERGE The 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 and index
information. You cannot merge MyISAM tables in which the columns are
listed in a different order, do not have exactly the same columns, or
have the indexes in different order. However, any or all of the MyISAM
tables can be compressed with myisampack. See
http://dev.mysql.com/doc/refman/5.7/en/myisampack.html. Differences in
table options such as AVG_ROW_LENGTH, MAX_ROWS, or PACK_KEYS do not
matter.
URL: http://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;
http://dev.mysql.com/doc/refman/5.7/en/merge-storage-engine.html< �@ " "� 6SHOW 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 database, except to see the
privileges for the current user.
To name the account, use the format described in
http://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: http://dev.mysql.com/doc/refman/5.7/en/show-create-user.html
http://dev.mysql.com/doc/refman/5.7/en/show-create-user.htmlT��@ { # "� 6ST_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 error occurs.
URL: http://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 |
+-----------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html8 �@ (� $ "� 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
| [CONSTRAINT [symbol]] PRIMARY KEY [index_type] (index_col_name,...)
[index_option] ...
| {INDEX|KEY} [index_name] [index_type] (index_col_name,...)
[index_option] ...
| [CONSTRAINT [symbol]] UNIQUE [INDEX|KEY]
[index_name] [index_type] (index_col_name,...)
[index_option] ...
| {FULLTEXT|SPATIAL} [INDEX|KEY] [index_name] (index_col_name,...)
[index_option] ...
| [CONSTRAINT [symbol]] FOREIGN KEY
[index_name] (index_col_name,...) reference_definition
| CHECK (expr)
column_definition:
data_type [NOT NULL | NULL] [DEFAULT default_value]
[AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY]
[COMMENT 'string']
[COLUMN_FORMAT {FIXED|DYNAMIC|DEFAULT}]
[STORAGE {DISK|MEMORY|DEFAULT}]
[reference_definition]
| data_type [GENERATED ALWAYS] AS (expression)
[VIRTUAL | STORED] [UNIQUE [KEY]] [COMMENT comment]
[NOT NULL | NULL] [[PRIMARY] KEY]
data_type:
BIT[(length)]
| TINYINT[(length)] [UNSIGNED] [ZEROFILL]
| SMALLINT[(length)] [UNSIGNED] [ZEROFILL]
| MEDIUMINT[(length)] [UNSIGNED] [ZEROFILL]
| INT[(length)] [UNSIGNED] [ZEROFILL]
| INTEGER[(length)] [UNSIGNED] [ZEROFILL]
| BIGINT[(length)] [UNSIGNED] [ZEROFILL]
| REAL[(length,decimals)] [UNSIGNED] [ZEROFILL]
| DOUBLE[(length,decimals)] [UNSIGNED] [ZEROFILL]
| FLOAT[(length,decimals)] [UNSIGNED] [ZEROFILL]
| DECIMAL[(length[,decimals])] [UNSIGNED] [ZEROFILL]
| NUMERIC[(length[,decimals])] [UNSIGNED] [ZEROFILL]
| DATE
| TIME[(fsp)]
| TIMESTAMP[(fsp)]
| DATETIME[(fsp)]
| YEAR
| CHAR[(length)] [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| VARCHAR(length) [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| BINARY[(length)]
| VARBINARY(length)
| TINYBLOB
| BLOB
| MEDIUMBLOB
| LONGBLOB
| TINYTEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| TEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| MEDIUMTEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| LONGTEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| ENUM(value1,value2,value3,...)
[CHARACTER SET charset_name] [COLLATE collation_name]
| SET(value1,value2,value3,...)
[CHARACTER SET charset_name] [COLLATE collation_name]
| JSON
| spatial_type
index_col_name:
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 (index_col_name,...)
[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:
ENGINE [=] engine_name
| 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 DIRECTORY [=] 'absolute path to directory'
| DELAY_KEY_WRITE [=] {0 | 1}
| ENCRYPTION [=] {'Y' | 'N'}
| INDEX DIRECTORY [=] 'absolute path to directory'
| 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|DEFAULT}]
| 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 [=] 'comment_text' ]
[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 [=] 'comment_text' ]
[DATA DIRECTORY [=] 'data_dir']
[INDEX DIRECTORY [=] 'index_dir']
[MAX_ROWS [=] max_number_of_rows]
[MIN_ROWS [=] min_number_of_rows]
[TABLESPACE [=] tablespace_name]
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.
For information about the physical representation of a table, see
http://dev.mysql.com/doc/refman/5.7/en/create-table-files.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/create-table.html
http://dev.mysql.com/doc/refman/5.7/en/create-table.htmlC��Ԁ@ 0� % "� 6)MICROSECOND Syntax:
MICROSECOND(expr)
Returns the microseconds from the time or datetime expression expr as a
number in the range from 0 to 999999.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MICROSECOND('12:00:00.123456');
-> 123456
mysql> SELECT MICROSECOND('2009-12-31 23:59:59.000010');
-> 10
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html9k��@ 8� & "� 66CREATE 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 should be mysql, and may be quoted with single
quotation marks. Other values for wrapper_name are not currently
supported.
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 will be used to populate
the columns in the mysql.servers table. The table columns are
Server_name, Host, Db, Username, Password, Port and Socket.
URL: http://dev.mysql.com/doc/refman/5.7/en/create-server.html
CREATE SERVER s
FOREIGN DATA WRAPPER mysql
OPTIONS (USER 'Remote', HOST '192.168.1.106', DATABASE 'test');
http://dev.mysql.com/doc/refman/5.7/en/create-server.htmlIA�˄@ @� ' "� 6CST_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 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
error occurs for other combinations.
An ER_GIS_INVALID_DATA error occurs if any geometry argument is not a
valid geometry byte string.
URL: http://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 |
+--------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html= ��@ H� ( "� 6PST_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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlC8�@ P� ) "� 6]MAKETIME 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MAKETIME(12,15,30);
-> '12:15:30'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlCb�@ XƳ * "� 6jCURDATE Syntax:
CURDATE()
Returns the current date as a value in 'YYYY-MM-DD' or YYYYMMDD format,
depending on whether the function is used in a string or numeric
context.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT CURDATE();
-> '2008-06-13'
mysql> SELECT CURDATE() + 0;
-> 20080613
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p t c 8�? �h� CdE� 9�� 7� infimum supremum8 ��@ J + "� 6wSET PASSWORD
Syntax:
SET PASSWORD syntax for MySQL 5.7.6 and higher:
The SET PASSWORD statement assigns a password to a MySQL user account,
specified as either a cleartext (unencrypted) or encrypted value:
o 'auth_string' represents a cleartext password.
o 'hash_string' represents an encrypted password.
*Note*:
o SET PASSWORD ... = PASSWORD('auth_string') syntax is deprecated as of
MySQL 5.7.6 and will be removed in a future MySQL release.
o SET PASSWORD ... = 'auth_string' syntax is not deprecated, but ALTER
USER is now the preferred statement for assigning passwords. For
example:
ALTER USER user IDENTIFIED BY 'auth_string';
SET PASSWORD can be used with or without an explicitly named 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' = password_option;
In this case, you must have the UPDATE privilege for the mysql
database.
o With no FOR user clause, the statement sets the password for the
current user:
SET PASSWORD = password_option;
Any client who connects to the server using a nonanonymous account
can change the password for that account. To see which account the
server authenticated you as, invoke the CURRENT_USER() function:
SELECT CURRENT_USER();
When the read_only system variable is enabled, SET PASSWORD requires
the SUPER privilege in addition to any other required privileges.
If a FOR user clause is given, the account name uses the format
described in http://dev.mysql.com/doc/refman/5.7/en/account-names.html.
The user value should be given as 'user_name'@'host_name', where
'user_name' and 'host_name' are exactly as listed in the User and Host
columns of the account's mysql.user table row. The host name part of
the account name, if omitted, defaults to '%'. For example, to set the
password for an account with User and Host column values of 'bob' and
'%.example.org', write the statement like this:
SET PASSWORD FOR 'bob'@'%.example.org' = PASSWORD('auth_string');
The password can be specified in these ways:
o Using the PASSWORD() function (deprecated as of MySQL 5.7.6)
The 'auth_string' function argument is the cleartext (unencrypted)
password. PASSWORD() hashes the password and returns the encrypted
password string for storage in the mysql.user account row.
The PASSWORD() function hashes the password using the hashing method
determined by the value of the old_passwords system variable value.
If SET PASSWORD rejects the hashed password value returned by
PASSWORD() as not being in the correct format, it may be necessary to
change old_passwords to change the hashing method. 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('mypass');
If the old_passwords value differs from that required by the
authentication plugin, the hashed password value returned by
PASSWORD() is not acceptable for that plugin, and attempts to set the
password produce an error. For example:
mysql> SET old_passwords = 1;
mysql> SET PASSWORD FOR 'jeffrey'@'localhost' = PASSWORD('mypass');
ERROR 1372 (HY000): Password hash should be a 41-digit hexadecimal number
Permitted old_passwords values are described later in this section.
o Using the OLD_PASSWORD() function (permitted before MySQL 5.7.5
only):
The 'auth_string' function argument is the cleartext (unencrypted)
password. OLD_PASSWORD() hashes the password using pre-4.1 hashing
and returns the encrypted password string for storage in the
mysql.user account row. This hashing method is appropriate only for
accounts that use the mysql_old_password authentication plugin.
*Note*:
Passwords that use the pre-4.1 hashing method are less secure than
passwords that use the native password hashing method and should be
avoided. Pre-4.1 passwords are deprecated and support for them is
removed in MySQL 5.7.5. Consequently, OLD_PASSWORD() is deprecated
and is removed in MySQL 5.7.5. For account upgrade instructions, see
http://dev.mysql.com/doc/refman/5.7/en/account-upgrades.html.
o Using a string without PASSWORD() or OLD_PASSWORD()
For this syntax, the meaning differs in MySQL 5.7.6 and higher from
earlier versions:
o As of MySQL 5.7.6, SET PASSWORD interprets the string as a
cleartext string and hashes it appropriately for the account
authentication plugin before storing it in the mysql.user account
row.
o Before MySQL 5.7.6, SET PASSWORD interprets the string as a hashed
password value to be stored directly. The string must be hashed in
the format required by the account authentication plugin. A string
not hashed appropriately causes client connections for the account
to fail with an Access denied error.
For more information about setting passwords, see
http://dev.mysql.com/doc/refman/5.7/en/assigning-passwords.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/set-password.html
http://dev.mysql.com/doc/refman/5.7/en/set-password.htmlCсo�@ � , "� 6�JSON_QUOTE JSON_QUOTE(json_val)
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
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
#json-unquote-character-escape-sequences.
URL: http://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]" |
+-------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.htmlA,��@ v - "� 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: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT DATABASE();
-> 'test'
http://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB��$�@ (c . "� 6�IF FUNCTION Syntax:
IF(expr1,expr2,expr3)
If expr1 is TRUE (expr1 <> 0 and expr1 <> NULL) then IF() returns
expr2; otherwise it returns expr3. IF() returns a numeric or string
value, depending on the context in which it is used.
URL: http://dev.mysql.com/doc/refman/5.7/en/control-flow-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'
http://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html= Ӏ@ 0l / "� 6�POINTFROMWKB !PointFromWKB(wkb[, srid])
ST_PointFromWKB() and PointFromWKB() are synonyms. For more
information, see the description of ST_PointFromWKB().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlB {@ 8 0 "� 6�POWER Syntax:
POWER(X,Y)
This is a synonym for POW().
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlBf��@ @� 1 "� 6�ATAN Syntax:
ATAN(X)
Returns the arc tangent of X, that is, the value whose tangent is X.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT ATAN(2);
-> 1.1071487177941
mysql> SELECT ATAN(-2);
-> -1.1071487177941
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html8Ɉ̋@ H* 2 "� 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*:
These statements are deprecated and will be removed in a future MySQL
release. Use the Performance Schema instead; see
http://dev.mysql.com/doc/refman/5.7/en/performance-schema-query-profili
ng.html.
Profiling is controlled by the profiling session variable, which has a
default value of 0 (OFF). Profiling is enabled 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
you will find neither of those statements 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 will show 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
http://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: http://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)
http://dev.mysql.com/doc/refman/5.7/en/show-profile.htmlBW0�@ Pȕ 3 "� 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 (as
of MySQL 5.7.4) a warning "Invalid argument for logarithm" is reported.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT LN(2);
-> 0.69314718055995
mysql> SELECT LN(-2);
-> NULL
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html p " c� Cdv|A� ! ��E� ;ʀ 8[ infimum supremum= ��@ � 4 "� 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
http://dev.mysql.com/doc/refman/5.7/en/charset-connection.html.
The default character set mapping can be restored by using the value
DEFAULT. The default depends on the server configuration.
ucs2, utf16, and utf32 cannot be used as a client character set, which
means that they do not work for SET CHARACTER SET.
URL: http://dev.mysql.com/doc/refman/5.7/en/set-character-set.html
http://dev.mysql.com/doc/refman/5.7/en/set-character-set.html2 @ g 5 "� 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: http://dev.mysql.com/doc/refman/5.7/en/return.html
http://dev.mysql.com/doc/refman/5.7/en/return.html; ��@ M 6 "� 6SET SQL_LOG_BIN Syntax:
SET sql_log_bin = {0|1}
The sql_log_bin variable controls whether logging to the binary log is
done. The default value is 1 (do logging). To change logging for the
current session, change the session value of this variable. The session
user must have the SUPER privilege to set this variable. Set this
variable to 0 for a session to temporarily disable binary logging while
making changes to the master which you do not want to replicate to the
slave.
As of MySQL 5.5, sql_log_bin can be set as a global or session
variable. Setting sql_log_bin globally is only detected when a new
session is started. Any sessions previously running are not impacted
when setting sql_log_bin globally.
*Warning*:
Incorrect use of sql_log_bin with a global scope means any changes made
in an already running session are still being recorded to the binary
log and therefore replicated. Exercise extreme caution using
sql_log_bin with a global scope as the above situation could cause
unexpected results including replication failure.
In MySQL 5.7, it is not possible to set @@session.sql_log_bin within a
transaction or subquery. (Bug #53437)
URL: http://dev.mysql.com/doc/refman/5.7/en/set-sql-log-bin.html
http://dev.mysql.com/doc/refman/5.7/en/set-sql-log-bin.html@ ��@ (� 7 "� 6AES_DECRYPT Syntax:
AES_DECRYPT(crypt_str,key_str[,init_vector])
This function decrypts data using the official AES (Advanced Encryption
Standard) algorithm. For more information, see the description of
AES_ENCRYPT().
The optional initialization vector argument, init_vector, is available
as of MySQL 5.7.4. As of that version, statements that use
AES_DECRYPT() are unsafe for statement-based replication and cannot be
stored in the query cache.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlAڀ��@ 0 8 "� 6 COERCIBILITY Syntax:
COERCIBILITY(str)
Returns the collation coercibility value of the string argument.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlA ր@ 8t 9 "� 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: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.htmlM �@ @� : "� 6:GLENGTH
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: http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html4 R�@ H� ; "� 6GSHUTDOWN Syntax:
SHUTDOWN
This statement stops the MySQL server. It requires the SHUTDOWN
privilege.
SHUTDOWN was added in MySQL 5.7.9. It provides an SQL-level interface
to the same functionality available using the mysqladmin shutdown
command or the mysql_shutdown() C API function.
URL: http://dev.mysql.com/doc/refman/5.7/en/shutdown.html
http://dev.mysql.com/doc/refman/5.7/en/shutdown.htmlG݀��@ P < "� 6TJSON_REMOVE 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: http://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"] |
+-------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlE���@ X = "� 6aST_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.
URL: http://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]} |
+-------------------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-geojson-functions.htmlF ��@ `\ > "� 6nST_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. The result is NULL if any argument is
NULL. If any argument is invalid, an 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 as of MySQL 5.7.8, 65,536 before
that. If the first argument is 'point_square' or 'end_flat', the
points_per_circle argument must not be given or an ER_WRONG_ARGUMENTS
error occurs.
For examples, see the description of ST_Buffer().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html<�t�@ h ? "� 6{MAKE_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: http://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');
-> ''
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html<7��@ pQ @ "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
-> 2
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html>}�@ x� A "� 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
-> FROM student
-> GROUP BY student_name;
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html3 ؊@ � h B "� 6�REPLACE Syntax:
REPLACE [LOW_PRIORITY | DELAYED]
[INTO] tbl_name
[PARTITION (partition_name,...)]
[(col_name,...)]
{VALUES | VALUE} ({expr | DEFAULT},...),(...),...
Or:
REPLACE [LOW_PRIORITY | DELAYED]
[INTO] tbl_name
[PARTITION (partition_name,...)]
SET col_name={expr | DEFAULT}, ...
Or:
REPLACE [LOW_PRIORITY | DELAYED]
[INTO] tbl_name
[PARTITION (partition_name,...)]
[(col_name,...)]
SELECT ...
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
http://dev.mysql.com/doc/refman/5.7/en/insert-on-duplicate.html.
DELAYED inserts and replaces were deprecated in MySQL 5.6.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 will be removed in a future 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.
If a generated column is replaced explicitly, the only permitted value
is DEFAULT. For information about generated columns, see
http://dev.mysql.com/doc/refman/5.7/en/create-table-generated-columns.h
tml.
To use REPLACE, you must have both the INSERT and DELETE privileges for
the table.
REPLACE supports explicit partition selection using the PARTITION
keyword with a comma-separated list of 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. See
http://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html, for
more information.
URL: http://dev.mysql.com/doc/refman/5.7/en/replace.html
http://dev.mysql.com/doc/refman/5.7/en/replace.htmlC @ �c C "� 6�CURRENT_TIMESTAMP Syntax:
CURRENT_TIMESTAMP, CURRENT_TIMESTAMP([fsp])
CURRENT_TIMESTAMP and CURRENT_TIMESTAMP() are synonyms for NOW().
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlF6���@ �� D "� 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))
URL: http://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_SymDifference(@g1, @g2));
+---------------------------------------+
| ST_AsText(ST_SymDifference(@g1, @g2)) |
+---------------------------------------+
| MULTIPOINT((1 1),(2 2)) |
+---------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html p"0� � cv|A� ��>|�S ! " �<E� ;o�
6* infimum supremum:׃�@ X E "� 6�GTID_SUBSET Syntax:
GTID_SUBSET(subset,set)
Given two sets of global transaction IDs subset and set, returns true
if all GTIDs in subset are also in set. Returns false otherwise.
URL: http://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)
http://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html> ��@ � F "� 6�VAR_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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlG 1�@ � G "� 6�DATETIME 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.999999'. 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
http://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.htmlE j�@ ( H "� 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
In MySQL 5.7.3 and later, CHANGE REPLICATION FILTER sets one or more
replication filtering rules on the slave in the same way as starting
the slave mysqld with replication filtering options such as
--replicate-do-db or --replicate-wild-ignore-table. Unlike the case
with the server options, this statement does not require restarting the
server to take effect, only that the slave SQL thread be stopped using
STOP SLAVE SQL_THREAD first (and restarted with START SLAVE SQL_THREAD
afterwards). CHANGE REPLICATION FILTER requires the SUPER privilege.
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 slave after substituting new
name on slave for specified database on master. 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
http://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 slave
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 dbA on the master
to database dbB on the slave:
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 perhap 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
http://dev.mysql.com/doc/refman/5.7/en/replication-rules.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/change-replication-filter.html
http://dev.mysql.com/doc/refman/5.7/en/change-replication-filter.htmlA ��@ 0+ I "� 6�INTEGER INTEGER[(M)] [UNSIGNED] [ZEROFILL]
This type is a synonym for INT.
URL: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html8 ��@ 8P J "� 6
SHOW COLUMNS Syntax:
SHOW [FULL] COLUMNS {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. 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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
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 | | | |
| Country | char(3) | NO | UNI | | |
| District | char(20) | YES | MUL | | |
| Population | int(11) | NO | | 0 | |
+------------+----------+------+-----+---------+----------------+
5 rows in set (0.00 sec)
If the data types differ from what you expect them to be based on a
CREATE TABLE statement, note that MySQL sometimes changes data types
when you create or alter a table. The conditions under which this
occurs are described in
http://dev.mysql.com/doc/refman/5.7/en/silent-column-changes.html.
The FULL keyword causes the output to include the column collation and
comments, as well as the privileges you have for each column.
You can use db_name.tbl_name as an alternative to the tbl_name FROM
db_name syntax. In other words, these two statements are equivalent:
mysql> SHOW COLUMNS FROM mytable FROM mydb;
mysql> SHOW COLUMNS FROM mydb.mytable;
SHOW COLUMNS displays the following values for each table column:
Field indicates the column name.
Type indicates the column data type.
Collation indicates the collation for nonbinary string columns, or NULL
for other columns. This value is displayed only if you use the FULL
keyword.
The Null field contains YES if NULL values can be stored in the column,
NO if not.
The Key field indicates 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.
The Default field indicates the default value that is assigned to the
column. This is NULL if the column has an explicit default of NULL, or
if the column definition has no DEFAULT clause.
The Extra field contains 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 VIRTUAL STORED for generated columns
Privileges indicates the privileges you have for the column. This value
is displayed only if you use the FULL keyword.
Comment indicates any comment the column has. This value is displayed
only if you use the FULL keyword.
SHOW FIELDS is a synonym for SHOW COLUMNS. You can also list a table's
columns with the mysqlshow db_name tbl_name command.
The DESCRIBE statement provides information similar to SHOW COLUMNS.
See http://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: http://dev.mysql.com/doc/refman/5.7/en/show-columns.html
http://dev.mysql.com/doc/refman/5.7/en/show-columns.htmlA Ā@ @b K "� 6TINYINT TINYINT[(M)] [UNSIGNED] [ZEROFILL]
A very small integer. The signed range is -128 to 127. The unsigned
range is 0 to 255.
URL: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.htmlC ��@ H�F L "� 6$MASTER_POS_WAIT Syntax:
MASTER_POS_WAIT(log_name,log_pos[,timeout][,channel_name])
This function is useful for control of master/slave synchronization. It
blocks until the slave has read and applied all updates up to the
specified position in the master log. The return value is the number of
log events the slave had to wait for to advance to the specified
position. The function returns NULL if the slave SQL thread is not
started, the slave's master information is not initialized, the
arguments are incorrect, or an error occurs. It returns -1 if the
timeout has been exceeded. If the slave SQL thread stops while
MASTER_POS_WAIT() is waiting, the function returns NULL. If the slave
is past the specified position, the function returns immediately.
If a timeout value is specified, MASTER_POS_WAIT() stops waiting when
timeout seconds have elapsed. timeout must be greater than 0; a zero or
negative timeout means no timeout.
The optional channel added in MySQL 5.7.6 enables you to choose which
replication channel the function applies to. See
http://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
URL: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html p A c>|�S �<�qp� " ! # E� ;� 4� infimum supremum9g��@ � M "� 61^ Syntax:
^
Bitwise XOR.
The result is an unsigned 64-bit integer.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html5 ��@ A N "� 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 of the views named in the argument list do not
exist, MySQL returns an error indicating by name which nonexisting
views it was unable to drop, but it also drops all of the views in the
list that do exist.
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: http://dev.mysql.com/doc/refman/5.7/en/drop-view.html
http://dev.mysql.com/doc/refman/5.7/en/drop-view.htmlCÀ�@ V O "� 6KWEEK 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
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html= ��@ (- P "� 6XDROP FUNCTION UDF Syntax:
DROP FUNCTION function_name
This statement drops the user-defined function (UDF) named
function_name.
To drop a function, you must have the DELETE privilege for the mysql
database. This is because DROP FUNCTION removes a row from the
mysql.func system table that records the function's name, type, and
shared library name.
URL: http://dev.mysql.com/doc/refman/5.7/en/drop-function-udf.html
http://dev.mysql.com/doc/refman/5.7/en/drop-function-udf.htmlI�%�@ 0� Q "� 6eST_VALIDATE ST_Validate(g)
Validates a geometry according to the OGC specification. ST_Validate()
returns the geometry if it is a valid geometry byte string and is
geometrically valid, NULL if the argument is not a valid geometry byte
string or is not geometrically valid or is NULL.
A geometry can be a valid geometry byte string (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() 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
error occurs otherwise.
URL: http://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) |
+------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-convenience-functions.html9v�)�@ 85 R "� 6rUPDATEXML &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: http://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>
http://dev.mysql.com/doc/refman/5.7/en/xml-functions.html7 �@ @
� S "� 6RESET SLAVE Syntax:
RESET SLAVE [ALL] [channel_option]
channel_option:
FOR CHANNEL channel
RESET SLAVE makes the slave forget its replication position in the
master's binary log. This statement is meant to be used for a clean
start: It clears the master info and relay log info 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. RESET SLAVE does not change the values of
gtid_executed or gtid_purged. To use RESET SLAVE, the slave replication
threads must be stopped, so on a running slave use STOP SLAVE before
issuing RESET SLAVE.
*Note*:
All relay log files are deleted, even if they have not been completely
executed by the slave SQL thread. (This is a condition likely to exist
on a replication slave if you have issued a STOP SLAVE statement or if
the slave is highly loaded.)
The optional FOR CHANNEL channel clause added in MySQL 5.7.6 enables
you to choose which replication channel the statement applies to. If no
clause is set and no extra channels exist, the statement applies to the
default channel and behaves the same as versions of MySQL prior to
5.7.6. 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.
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
http://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 master host, master port, master user, or master password, which are
retained in memory. This means that START SLAVE can be issued without
requiring a CHANGE MASTER TO statement following RESET SLAVE.
Connection parameters are reset by RESET SLAVE ALL. (RESET SLAVE
followed by a restart of the slave mysqld also does this.)
In MySQL 5.7 RESET SLAVE causes an implicit commit of an ongoing
transaction. See
http://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
If the slave 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 slave.
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 a MySQL Cluster replication slave 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 slave cluster.
You can override this behavior by issuing SET GLOBAL
@@ndb_clear_apply_status=OFF prior to executing RESET SLAVE, which
keeps the slave from purging the ndb_apply_status table in such cases.
URL: http://dev.mysql.com/doc/refman/5.7/en/reset-slave.html
http://dev.mysql.com/doc/refman/5.7/en/reset-slave.htmlE/���@ H\ T "� 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. The srid value is an unsigned 32-bit integer. The
result is NULL if any argument is NULL. An error occurs if any argument
is invalid.
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: http://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) |
+---------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.htmlC ��@ P# U "� 6�DAY Syntax:
DAY(date)
DAY() is a synonym for DAYOFMONTH().
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlCH�@ X� V "� 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
and Linux. On other operating systems, MySQL uses a randomly
generated 48-bit number.
URL: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT UUID();
-> '6ccd780c-baba-1026-9564-5b8c656024db'
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlH ��@ `� W "� 6�LINESTRING LineString(pt1, pt2, ...)
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: http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.htmlC �@ h�� X "� 6�SLEEP 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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html p%�� c�qp� �$x� # " $ S9E� ; � 6�
infimum supremum@ �@ Y "� 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 [=] comment_text]
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
http://dev.mysql.com/doc/refman/5.7/en/identifiers.html.
*Note*:
All MySQL 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 MySQL 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 MySQL 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 MySQL
Cluster. See
http://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/create-logfile-group.html
http://dev.mysql.com/doc/refman/5.7/en/create-logfile-group.htmlBS�@ � Z "� 6�NULLIF 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.
URL: http://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html
mysql> SELECT NULLIF(1,1);
-> NULL
mysql> SELECT NULLIF(1,2);
-> 1
http://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.htmlB�H�@ � [ "� 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.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html6 I�@ (� \ "� 6�STOP SLAVE Syntax:
STOP SLAVE [thread_types]
thread_types:
[thread_type [, thread_type] ... ]
thread_type: IO_THREAD | SQL_THREAD
channel_option:
FOR CHANNEL channel
Stops the slave threads. STOP SLAVE requires the SUPER privilege.
Recommended best practice is to execute STOP SLAVE on the slave before
stopping the slave server (see
http://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 slave prior to shutting down the slave
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.
In MySQL 5.7, STOP SLAVE causes an implicit commit of an ongoing
transaction. See
http://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
Beginning with MySQL 5.7.1, gtid_next must be set to AUTOMATIC before
issuing this statement (Bug #16062608).
In MySQL 5.7.2 and later, 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 slave SQL statements using different client connections to the
slave. (Bug #16856735)
Prior to MySQL 5.7.4, it was necessary to issue this statement on a
running slave prior to executing CHANGE MASTER TO. In MySQL 5.7.4 and
later, this is no longer always the case; some CHANGE MASTER TO
statements are now allowed while the slave is running, depending on the
states of the slave SQL and I/O threads. However, using STOP SLAVE
prior to executing CHANGE MASTER TO in such cases is still supported.
See [HELP CHANGE MASTER TO], and
http://dev.mysql.com/doc/refman/5.7/en/replication-solutions-switch.htm
l, for more information.
The optional FOR CHANNEL channel clause added in MySQL 5.7.6 enables
you to choose which replication channel the statement applies to. If no
clause is set and no extra channels exist, the statement applies to the
default channel and behaves the same as versions of MySQL prior to
5.7.6. Providing a FOR CHANNEL channel clause applies the STOP SLAVE
statement to a specific replication channel. If a STOP SLAVE statement
does not have a channel defined when using multiple channels, this
statement stops the specified threads for all channels. Beginning with
MySQL 5.7.9, this statement cannot be used with the
group_replication_recovery channel. See
http://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
When using statement-based replication: changing the master 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 slave by checking the value of Slave_open_temp_tables; when using
statement-based replication, this value should be 0 before executing
CHANGE MASTER TO. In MySQL 5.7.4 and later, if there are any temporary
tables open on the slave, issuing a CHANGE MASTER TO statement after
issuing a STOP SLAVE causes an ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO
warning.
When using a multi-threaded slave (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
slave 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
http://dev.mysql.com/doc/refman/5.7/en/replication-features-transaction
-inconsistencies.html, for more information.
In MySQL 5.7, STOP SLAVE waits until the current replication
transaction affecting one or more nontransactional tables has finished
executing (if there is any such transaction), or until you issue a KILL
QUERY or KILL CONNECTION statement. (Bug #319, Bug #38205)
URL: http://dev.mysql.com/doc/refman/5.7/en/stop-slave.html
http://dev.mysql.com/doc/refman/5.7/en/stop-slave.htmlC
�@ 0x ] "� 6TIMEDIFF Syntax:
TIMEDIFF(expr1,expr2)
TIMEDIFF() returns expr1 − expr2 expressed as a time value. expr1 and
expr2 are time or date-and-time expressions, but both must be of the
same type.
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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html= $�@ 8� ^ "� 6LINEFROMTEXT 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.htmlCɀ�@ @P _ "� 6ADDTIME 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html< M�@ H� ` "� 6(UPPER &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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@ �@ P� a "� 65MEDIUMBLOB 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.htmlC"���@ Xɴ b "� 6BFROM_UNIXTIME Syntax:
FROM_UNIXTIME(unix_timestamp), FROM_UNIXTIME(unix_timestamp,format)
Returns a representation of the unix_timestamp argument as a value in
'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS format, depending on whether
the function is used in a string or numeric context. The value is
expressed in the current time zone. unix_timestamp is an internal
timestamp value such as is produced by the UNIX_TIMESTAMP() function.
If format is given, the result is formatted according to the format
string, which is used the same way as listed in the entry for the
DATE_FORMAT() function.
URL: http://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(UNIX_TIMESTAMP(),
-> '%Y %D %M %h:%i:%s %x');
-> '2015 13th November 10:08:01 2015'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p� c�$x� S9�|� $ # % ��E� ;$� += infimum supremum@f�@ � c "� 6OSHA2 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 cleartext 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 nonbinary string in the connection character set.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT SHA2('abc', 224);
-> '23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7'
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlB�� �@ ] d "� 6\IFNULL Syntax:
IFNULL(expr1,expr2)
If expr1 is not NULL, IFNULL() returns expr1; otherwise it returns
expr2. IFNULL() returns a numeric or string value, depending on the
context in which it is used.
URL: http://dev.mysql.com/doc/refman/5.7/en/control-flow-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'
http://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html> ׀@ r e "� 6iSHOW 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: http://dev.mysql.com/doc/refman/5.7/en/show-function-code.html
http://dev.mysql.com/doc/refman/5.7/en/show-function-code.html7 ��@ (H f "� 6vSHOW 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/show-errors.html
http://dev.mysql.com/doc/refman/5.7/en/show-errors.html5 g�@ 0� g "� 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
http://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.
The default mapping can be restored by using a value of DEFAULT. The
default depends on the server configuration.
ucs2, utf16, and utf32 cannot be used as a client character set, which
means that they do not work for SET NAMES.
URL: http://dev.mysql.com/doc/refman/5.7/en/set-names.html
http://dev.mysql.com/doc/refman/5.7/en/set-names.html@��*�@ 8W h "� 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 the return value is used in an INTEGER context or all arguments
are integer-valued, they are compared as integers.
o If the return value is used in a REAL context or all arguments are
real-valued, they are compared as reals.
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.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html@��R@ @� i "� 6�= =
Equal:
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html=^���@ H} j "� 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.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
URL: http://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)) |
+--------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.htmlC��b�@ P� k "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html7 ��@ X" l "� 6�CREATE USER
Syntax:
CREATE USER syntax for MySQL 5.7.6 and higher:
The CREATE USER statement creates new MySQL accounts. It enables
account authentication properties to be established. As of MySQL 5.7.6,
it is also possible to establish authentication, SSL/TLS, and
resource-limit properties, account password expiration, and account
locking and unlocking.
An account when first created has no privileges.
To use CREATE USER, you must have the global CREATE USER privilege, or
the INSERT privilege for the mysql 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.
As of MySQL 5.7.8, the IF NOT EXISTS clause can be used, which causes
the statement to produce a warning for each named account that already
exists, rather than an error.
For each account, CREATE USER creates a new row in the mysql.user
table. The row reflects the properties specified in the statement.
Unspecified properties are set to their default values.
Example 1: Create an account that uses the default authentication
plugin and the given password. Mark the password expired so that the
user must choose a new one at the first connection to the server:
CREATE USER 'jeffrey'@'localhost'
IDENTIFIED BY 'new_password' PASSWORD EXPIRE;
Example 2: Create an account that uses the sha256_password
authentication plugin and the given password. Require that a new
password be chosen every 180 days:
CREATE USER 'jeffrey'@'localhost'
IDENTIFIED WITH sha256_password BY 'new_password'
PASSWORD EXPIRE INTERVAL 180 DAY;
URL: http://dev.mysql.com/doc/refman/5.7/en/create-user.html
http://dev.mysql.com/doc/refman/5.7/en/create-user.htmlH ��@ `+ m "� 6�POINT Point(x, y)
Constructs a Point using its coordinates.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html< z@ h n "� 6�LCASE &Syntax:
LCASE(str)
LCASE() is a synonym for LOWER().
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlK'�@ p� o "� 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @dhp = CREATE_DH_PARAMETERS(1024);
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html@Q��@ xo p "� 6�IS NOT NULL Syntax:
IS NOT NULL
Tests whether a value is not NULL.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html;����@ ��3 q "� 6MATCH 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 As of MySQL 5.7.6, 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
http://dev.mysql.com/doc/refman/5.7/en/fulltext-search-ngram.html,
and
http://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. The stopword list applies. For more information about
stopword lists, see
http://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
http://dev.mysql.com/doc/refman/5.7/en/fulltext-natural-language.html
.
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
http://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
http://dev.mysql.com/doc/refman/5.7/en/fulltext-query-expansion.html.
URL: http://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)
http://dev.mysql.com/doc/refman/5.7/en/fulltext-search.html p�E c�|� ����1c % $ & �8E� ;t� 9� infimum supremum8 ߉@
t r "� 6CREATE EVENT (Syntax:
CREATE
[DEFINER = { user | CURRENT_USER }]
EVENT
[IF NOT EXISTS]
event_name
ON SCHEDULE schedule
[ON COMPLETION [NOT] PRESERVE]
[ENABLE | DISABLE | DISABLE ON SLAVE]
[COMMENT 'comment']
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 will not
run unless the Event Scheduler is enabled. For information about
checking Event Scheduler status and enabling it if necessary, see
http://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. It might also require the SUPER privilege,
depending on the DEFINER value, as described later in this section.
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
http://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: http://dev.mysql.com/doc/refman/5.7/en/create-event.html
http://dev.mysql.com/doc/refman/5.7/en/create-event.html>:̀@ � s "� 6 MBR DEFINITION Its MBR (minimum bounding rectangle), or envelope. This is the bounding
geometry, formed by the minimum and maximum (X,Y) coordinates:
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-class-geometry.html
((MINX MINY, MAXX MINY, MAXX MAXY, MINX MAXY, MINX MINY))
http://dev.mysql.com/doc/refman/5.7/en/gis-class-geometry.htmlF$�À@ � t "� 6,ST_DIFFERENCE ST_Difference(g1, g2)
Returns a geometry that represents the point set difference of the
geometry values g1 and g2.
URL: http://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) |
+------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlH �@ (� u "� 69GEOMETRYCOLLECTION GeometryCollection(g1, g2, ...)
Constructs a GeometryCollection.
As of MySQL 5.7.5, GeometryCollection() returns all the proper
geometries contained in the argument even if a nonsupported geometry is
present. Before 5.7.5, if the argument contains a nonsupported
geometry, the return value is NULL.
As of MySQL 5.7.8, GeometryCollection() with no arguments is permitted
as a way to create an empty geometry.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-mysql-specific-functions.html@րc@ 0� v "� 6F* Syntax:
*
Multiplication:
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlK!��@ 8r w "� 6SST_ASBINARY !ST_AsBinary(g), ST_AsWKB(g)
Converts a value in internal geometry format to its WKB representation
and returns the binary result.
The result is NULL if the geometry argument is NULL. If the argument is
not a syntactically well-formed geometry, an ER_GIS_INVALID_DATA error
occurs as of MySQL 5.7.5. The result is NULL prior to MySQL 5.7.5.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html
SELECT ST_AsBinary(g) FROM geom;
http://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html<X��@ @� 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
-> 'JWJj', 'abc'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@ �@ H y "� 6mDES_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 http://dev.mysql.com/doc/refman/5.7/en/secure-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 as of
MySQL 5.7.6, will be removed in a future MySQL release, and should no
longer be used. Consider using AES_ENCRYPT() and AES_DECRYPT() instead.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlJj���@ P� z "� 6zST_AREA ST_Area(poly)
Returns a double-precision number indicating the area of the argument,
as measured in its spatial reference system. For arguments of dimension
0 or 1, the result is 0.
Additionally, as of MySQL 5.7.5: 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: http://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 |
+----------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlM ʀ@ Xt { "� 6�ENDPOINT
EndPoint(ls)
ST_EndPoint() and EndPoint() are synonyms. For more information, see
the description of ST_EndPoint().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html2 ��@ `� | "� 6�INSERT Syntax:
INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name,...)]
[(col_name,...)]
{VALUES | VALUE} ({expr | DEFAULT},...),(...),...
[ ON DUPLICATE KEY UPDATE
col_name=expr
[, col_name=expr] ... ]
Or:
INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name,...)]
SET col_name={expr | DEFAULT}, ...
[ ON DUPLICATE KEY UPDATE
col_name=expr
[, col_name=expr] ... ]
Or:
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
[INTO] tbl_name
[PARTITION (partition_name,...)]
[(col_name,...)]
SELECT ...
[ ON DUPLICATE KEY UPDATE
col_name=expr
[, col_name=expr] ... ]
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 ... SELECT is discussed
further in [HELP INSERT SELECT].
When inserting into a partitioned table, you can control which
partitions and subpartitions accept new rows. The PARTITION option
takes a comma-separated list of the 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. See
http://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html, for
more information and examples.
In MySQL 5.7, the DELAYED keyword is accepted but ignored by the
server. See [HELP INSERT DELAYED], for the reasons for this.
URL: http://dev.mysql.com/doc/refman/5.7/en/insert.html
http://dev.mysql.com/doc/refman/5.7/en/insert.html>���@ hZ } "� 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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
mysql> SELECT student.student_name,COUNT(*)
-> FROM student,course
-> WHERE student.student_id=course.student_id
-> GROUP BY student_name;
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlG�!�@ p � ~ "� 6�JSON_ARRAY_APPEND 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: http://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"] |
+---------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html= 7�@ x� "� 6�MLINEFROMTEXT 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html= E�@ ��� � "� 6�GEOMCOLLFROMWKB !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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html p�# c��1c �8+}m & % @ �E� 74�
3�
infimum supremum@ ��@ $ � "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.htmlC5ɀ@ � � "� 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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html: ֈ@ m � "� 6�OPTIMIZE TABLE Syntax:
OPTIMIZE [NO_WRITE_TO_BINLOG | LOCAL] TABLE
tbl_name [, tbl_name] ...
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. This statement does not work with views.
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 is also supported for partitioned tables. For
information about using this statement with partitioned tables and
table partitions, see
http://dev.mysql.com/doc/refman/5.7/en/partitioning-maintenance.html.
In MySQL 5.7.1, gtid_next must be set to AUTOMATIC before issuing this
statement. This restriction does not apply in MySQL 5.7.2 or later.
(Bug #16062608, Bug #16715809, Bug #69045)
URL: http://dev.mysql.com/doc/refman/5.7/en/optimize-table.html
http://dev.mysql.com/doc/refman/5.7/en/optimize-table.html@ ��@ (\ � "� 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, will
be removed in a future MySQL release, and should no longer be used.
Consider using AES_ENCRYPT() and AES_DECRYPT() instead.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlG��܃@ 0
� "� 6 JSON_ARRAY_INSERT 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: http://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]] |
+----------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html@��e�@ 8� � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html1 �@ @� � "� 6#RESET Syntax:
RESET reset_option [, reset_option] ...
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
http://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
In MySQL 5.7.1, gtid_next must be set to AUTOMATIC before issuing this
statement. This restriction does not apply in MySQL 5.7.2 or later.
(Bug #16062608, Bug #16715809, Bug #69045)
reset_option can be any of the following:
o 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 QUERY CACHE
Removes all query results from the query cache.
o SLAVE
Makes the slave forget its replication position in the master binary
logs. Also resets the relay log by deleting any existing relay log
files and beginning a new one.
URL: http://dev.mysql.com/doc/refman/5.7/en/reset.html
http://dev.mysql.com/doc/refman/5.7/en/reset.htmlC ]�@ H
� � "� 60GET_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). Lock release may also occur with another call
to GET_LOCK():
o Before 5.7.5, only a single simultaneous lock can be acquired and
GET_LOCK() releases any existing lock.
o In MySQL 5.7.5, 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, 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. Also, the capability of acquiring multiple
locks introduces 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 error. This
error does not cause transactions to roll back.
The difference in lock acquisition behavior as of MySQL 5.7.5 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.5 or later, the second GET_LOCK() acquires a second lock
and both RELEASE_LOCK() calls return 1 (success). Before MySQL 5.7.5,
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.5 and later enforces a maximum length on lock names of 64
characters. Previously, no limit was enforced.
Locks obtained with GET_LOCK() are not released when transactions
commit or roll back.
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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlA 7�@ P� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.htmlCe��@ X� � "� 6JCURTIME 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 a string or numeric
context. The value is expressed in the current 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlJa�K�@ `̅ � "� 6WST_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
http://dev.mysql.com/doc/refman/5.7/en/gis-class-geometry.html.
URL: http://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 |
+------------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html p
� c+}m �{��E ' ���� "%�E� !3��� 3^ � " infimum supremum@ 2LSHOW PRIVILEGES x@ /�SHOW PROCEDURE STATUS �@ JSHOW PROFILE 2@ ( JSHOW PROFILES 4@ 0 JSHOW RELAYLOG EVENTS @ 8 JSHOW SLAVE HOSTS �@ @ JSHOW SLAVE STATUS �@ H JSHOW STATUS �@ P JSHOW TABLE STATUS �@ X JSHOW TABLES �@ `(.SHOW TRIGGERS @ h TSHUTDOWN ;@ p JSIN @ x JSLEEP X@ �!�SMALLINT �@ � JSPACE >@ � JSPATIAL ,@ � JSQRT �@ �"�SRID @ �,START TRANSACTION �@ � JSTDDEV @ � JSTDDEV_POP �@ � JSTDDEV_SAMP �@ �+\STOP SLAVE \@ � JSTR_TO_DATE �@ � JST_AREA z@ � JST_ASBINARY w@ � JST_ASGEOJSON =@ � JST_ASTEXT T@ � JST_BUFFER @ JST_BUFFER_STRATEGY >@ JST_CENTROID @ NST_CONTAINS �@ JST_DIFFERENCE t@ !�ST_DIMENSION �@( JST_DISTANCE #@ 0NST_DISTANCE_SPHERE '@ 8"�ST_ENVELOPE �@ @ JST_GEOHASH �@H JST_GEOMCOLLFROMTEXT j@ P JST_GEOMCOLLFROMWKB @ X JST_GEOMETRYN @ `"fST_GEOMETRYTYPE K@h"fST_GEOMFROMTEXT z@ p JST_INTERSECTS @ x JST_ISCLOSED _@ � JST_ISEMPTY �@� JST_ISSIMPLE �@ � `ST_ISVALID �@ � JST_LINEFROMWKB �@ � JST_LONGFROMGEOHASH f@�"fST_MAKEENVELOPE @ � JST_MLINEFROMWKB �@ �ST_MPOINTFROMTEXT �@ �!>ST_MPOLYFROMWKB �@� JST_NUMINTERIORRINGS �@ ��ST_NUMPOINTS �@ ��ST_POINTFROMGEOHASH T@ � JST_POINTFROMWKB @� JST_POINTN @ � JST_POLYFROMTEXT �@ � JST_POLYFROMWKB (@ �ST_SIMPLIFY 7@ JST_STARTPOINT /@ JST_SYMDIFFERENCE D@ JST_TOUCHES �@ JST_UNION �@( JST_VALIDATE Q@ 0�ST_WITHIN @ 8 �ST_Y �@@�SUBSTR @H�SYSDATE �@ P6TEXT �@ X JTIME FUNCTION �@ ` JTIMEDIFF ]@h
hTIMESTAMP A@ p JTIMESTAMPDIFF +@ x�TIME_FORMAT �@ � JTINYBLOB @� JTINYINT K@ �
�TINYTEXT �@ �RTO_BASE64 x@ ��TO_SECONDS *@��TRUE FALSE �@ � �UCASE M@ � JUNHEX �@ �
�UNINSTALL PLUGIN �@� JUPDATE 5@ � JUPDATEXML R@ � JUPPER `@ � JUSE '@��USER @ �UTC_TIME �@�UUID V@ tVALIDATE_PASSWORD_STRENGTH @ JVARCHAR �@ JVARIANCE @ JVAR_POP �@ �VAR_SAMP F@(0WAIT_FOR_EXECUTED_GTID_SET @ 0�WEEK O@ 8 JWITHIN @ @ JWKT DEFINITION �@H�X �@ P JXOR |@ X JY �@ `�YEAR �@ h�^ M@ p�~ �@ xSIGN �@ ��pSUBDATE �@ �
hTIMESTAMP FUNCTION �@ ��ST_MPOINTFROMWKB �@ �STARTPOINT �@ ���YEARWEEK �@ ���UNIX_TIMESTAMP �@ ��0ST_INTERSECTION �@ ���TOUCHES �@ �UNCOMPRESS �@ �"ST_INTERIORRINGN �@ ��STD �@ ���TAN �@� �WEEKOFYEAR �@ �~ST_CONVEXHULL �@ ��SUBTIME �@��pUNCOMPRESSED_LENGTH �@ �XST_POINTFROMTEXT �@ �ST_ENDPOINT �@ �zST_OVERLAPS �@��YEAR DATA TYPE �@ ��SUM �@ (\SOUNDEX �@ 0�NVARBINARY �@ 8��UNION �@ @�TO_DAYS �@ H�TIME �@ P��SYSTEM_USER �@ X�TRUNCATE TABLE �@ `ݚSTART SLAVE �@ h� SHOW WARNINGS �@ p�ST_LINEFROMTEXT @ x(SUBSTRING @ ��~ST_CROSSES @ ��FST_MPOLYFROMTEXT @ ���VALUES
@ ���SUBSTRING_INDEX @ ��ST_X
@ ��zTIMESTAMPADD @ ���TRUNCATE @ �� SHOW VARIABLES @ ���ST_DISJOINT @ ��WEEKDAY @ ��TIME_TO_SEC @ �� SOUNDS LIKE #@ ��ST_SRID .@ ��WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS 2@ �~WEIGHT_STRING 4@ � ST_EQUALS 5@ �| 8@ �6UUID_SHORT ;@ xST_LATFROMGEOHASH >@ ��ST_GEOMFROMGEOJSON ?@ �ST_GEOMFROMWKB D@ (�zUTC_DATE H@ 0�XA K@ 8�0UTC_TIMESTAMP O@ @ИSHOW PROCESSLIST V@ H�TRIM Z@ P��SIGNAL \@ X� ST_NUMGEOMETRIES ^@ `��ST_MLINEFROMTEXT d@ hَST_EXTERIORRING g@ p��ST_LENGTH m@ x��STRCMP n@ ��SHOW PROCEDURE CODE p@ ��WHILE u@ ��VERSION | p%� D#� �`��$�|T,����d< � �
� tL$����\ c{��E "%���% ( "E� ,h�� ,$ � " infimum supremum@ JDIV �@ "fDO Q@ JDOUBLE PRECISION �@ (!>DROP DATABASE �@ 0 JDROP FUNCTION �@ 8 JDROP FUNCTION UDF P@ @% DROP INDEX 9@ H �DROP SERVER @ P JDROP TABLESPACE @ X `DROP TRIGGER �@ ` JDROP VIEW N@ h JDUAL �@ p ELT e@ x JENCRYPT �@ �&rENDPOINT {@ �#�ENVELOPE �@ � JEXECUTE STATEMENT 8@ � JEXP �@ � �EXPLAIN �@ � JEXTERIORRING Z@ � JEXTRACT �@ � JEXTRACTVALUE V@ �#�FETCH �@ � JFIND_IN_SET @@ �pFLOAT �@ � JFLUSH �@ � JFLUSH QUERY CACHE `@ � JFORMAT X@ � TFOUND_ROWS �@ � JFROM_DAYS @ FROM_UNIXTIME b@ JGEOMCOLLFROMWKB �@ JGEOMETRY �@ JGEOMETRY HIERARCHY @ JGEOMETRYCOLLECTION u@( �GEOMETRYN �@ 0 JGEOMFROMWKB [@ 8 JGET DIAGNOSTICS �@ @ JGET_FORMAT @H JGET_LOCK �@ P JGLENGTH :@ X JGRANT }@ `�GREATEST �@h�GTID_SUBSET E@ p�HANDLER E@ x JHELP STATEMENT L@ � JHELP_DATE F@� JHELP_VERSION v@ ��HEX @ � JIF FUNCTION .@ � JIF STATEMENT @�BIFNULL d@ �NINET6_ATON �@ �&INET_ATON �@ �,INSERT |@� JINSERT FUNCTION {@ ��INSERT SELECT �@ � JINSTR �@ � JINT 9@� JINTEGER I@ � JINTERIORRINGN �@ � JINTERSECTS �@ JINTERVAL
@ JIS @ JIS NOT @ JIS NOT NULL p@ JIS NULL �@(�ISCLOSED @ 0 JISNULL .@ 8 JISOLATION @ @ FISSIMPLE �@H JIS_IPV4 ;@ P JIS_IPV4_COMPAT �@ X $IS_IPV4_MAPPED k@ ` JITERATE P@h�JOIN @ p JJSON_ARRAY �@ x JJSON_ARRAY_APPEND ~@ � JJSON_ARRAY_INSERT �@��JSON_CONTAINS �@ � JJSON_EXTRACT I@ � JJSON_INSERT l@ ��JSON_KEYS �@� JJSON_MERGE �@ � JJSON_OBJECT @ � JJSON_QUOTE ,@ � �JSON_REMOVE <@��JSON_SEARCH $@ � JJSON_TYPE U@ � JJSON_UNQUOTE m@ � JJSON_VALID �@��KILL o@ �~LAST_DAY �@ � JLCASE n@ JLEAST h@ JLEAVE �@
hLEFT ^@ JLIKE �@ nLINEFROMTEXT ^@( JLINESTRING W@ 0
hLN 3@ 8 JLOAD XML �@ @
LOAD_FILE �@ H JLOCATE j@ P
LOCK @ X�LONGTEXT n@ `
�JSON_CONTAINS_PATH �@ h�LOG10 �@p��LOCALTIMESTAMP �@ x�IS_FREE_LOCK �@ ��*GEOMCOLLFROMTEXT �@ ���LAST_INSERT_ID �@ ���FLOOR �@ � �LOG2 �@ ��\DROP TABLE �@ ��IS_IPV6 �@ ���LONGBLOB �@ ���JSON_SET �@ �� DROP EVENT �@ ��LOAD INDEX �@ ���DOUBLE �@ ���DROP USER @ ��dISEMPTY @ ��4ENCODE @ ��RHOUR @ ��LGROUP_CONCAT @ �FROM_BASE64 @ ��EXPORT_SET !@ �IN '@ �HELP COMMAND )@ �JSON_REPLACE *@ (�IS_USED_LOCK ,@ 0��LENGTH 3@ 8�GEOMFROMTEXT :@ @�JDROP PROCEDURE =@ H�tINSTALL PLUGIN @@ P�LOAD DATA B@ X��LOCALTIME C@ `ܼEQUALS L@ h�GTID_SUBTRACT R@ p�$INET_NTOA S@ x��LINEFROMWKB W@ ��fGEOMETRYTYPE X@ ��INET6_NTOA [@ ��JSON_DEPTH _@ ��LABELS `@ ��rFIELD h@ ���ENUM l@ �� INSERT DELAYED o@ ���LOG s@ ��JSON_APPEND v@ ��XJSON_LENGTH w p � ���|T,���d< � �
� tL$����\ c��% " ��_� @ & A S�E� ;w�
8�
infimum supremum8 I�@ � � "� 6dSET Syntax:
SET variable_assignment [, variable_assignment] ...
variable_assignment:
user_var_name = expr
| param_name = expr
| local_var_name = expr
| [GLOBAL | SESSION]
system_var_name = expr
| [@@global. | @@session. | @@]
system_var_name = expr
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 System variables. See
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
System variables also can be set at server startup, as described in
http://dev.mysql.com/doc/refman/5.7/en/using-system-variables.html.
(To display system variable names and values, use the SHOW VARIABLES
statement; see [HELP SHOW VARIABLES].)
o User-defined variables. See
http://dev.mysql.com/doc/refman/5.7/en/user-variables.html.
o Stored procedure and function parameters, and stored program local
variables. See
http://dev.mysql.com/doc/refman/5.7/en/stored-program-variables.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/set-variable.html
http://dev.mysql.com/doc/refman/5.7/en/set-variable.htmlGق@ K � "� 6qJSON_MERGE JSON_MERGE(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
http://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: http://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] |
+---------------------------------------+
mysql> SELECT JSON_MERGE('{"name": "x"}', '{"id": 47}');
+-------------------------------------------+
| JSON_MERGE('{"name": "x"}', '{"id": 47}') |
+-------------------------------------------+
| {"id": 47, "name": "x"} |
+-------------------------------------------+
mysql> SELECT JSON_MERGE('1', 'true');
+-------------------------+
| JSON_MERGE('1', 'true') |
+-------------------------+
| [1, true] |
+-------------------------+
mysql> SELECT JSON_MERGE('[1, 2]', '{"id": 47}');
+------------------------------------+
| JSON_MERGE('[1, 2]', '{"id": 47}') |
+------------------------------------+
| [1, 2, {"id": 47}] |
+------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html4 ?�@ � � "� 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,...)]
[SET col_name = expr,...]
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:
shell> mysql --xml -e 'SELECT * FROM mydb.mytable' > file.xml
To read the file back into a table, use LOAD XML INFILE. 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.
Prior to MySQL 5.7.9, LOAD XML did not handle empty XML elements in the
form <element/> correctly. (Bug #67542, Bug #16171518)
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 comma-separated list of one or more
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: http://dev.mysql.com/doc/refman/5.7/en/load-xml.html
http://dev.mysql.com/doc/refman/5.7/en/load-xml.htmlBA�@ (� � "� 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html= �@ 0� � "� 6�ST_MPOINTFROMTEXT ST_MPointFromText(wkt[, srid]), ST_MultiPointFromText(wkt[, srid])
Constructs a MultiPoint value using its WKT representation and SRID.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
As of MySQL 5.7.9, spatial 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, whereas before MySQL 5.7.9 the second one produces an error:
ST_MPointFromText('MULTIPOINT (1 1, 2 2, 3 3)')
ST_MPointFromText('MULTIPOINT ((1 1), (2 2), (3 3))')
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html@M��@ 8� � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/assignment-operators.html< k�@ @ � "� 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
http://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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-open-tables.html
http://dev.mysql.com/doc/refman/5.7/en/show-open-tables.htmlCF��@ H� � "� 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.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT EXTRACT(YEAR FROM '2009-07-02');
-> 2009
mysql> SELECT EXTRACT(YEAR_MONTH FROM '2009-07-02 01:02:03');
-> 200907
mysql> SELECT EXTRACT(DAY_MINUTE FROM '2009-07-02 01:02:03');
-> 20102
mysql> SELECT EXTRACT(MICROSECOND
-> FROM '2003-01-02 10:30:00.000123');
-> 123
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html@;��@ P� � "� 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 the result will be NULL. If no salt argument is given, a random
value is used.
*Note*:
The ENCRYPT() function is deprecated as of MySQL 5.7.6, will be removed
in a future MySQL release, and should no longer be used. Consider using
AES_ENCRYPT() instead.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT ENCRYPT('hello');
-> 'VxuFAJXVARROc'
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html7 ��@ X / � "� 6�SHOW STATUS Syntax:
SHOW [GLOBAL | SESSION] STATUS
[LIKE 'pattern' | WHERE expr]
*Note*:
As of MySQL 5.7.6, 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
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
SHOW STATUS provides server status information (see
http://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
http://dev.mysql.com/doc/refman/5.7/en/performance-schema-status-vari
able-tables.html.
o The GLOBAL_STATUS and SESSION_STATUS tables. See
http://dev.mysql.com/doc/refman/5.7/en/status-table.html.
o The mysqladmin extended-status command. See
http://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
http://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
http://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: http://dev.mysql.com/doc/refman/5.7/en/show-status.html
http://dev.mysql.com/doc/refman/5.7/en/show-status.htmlJ}�ǀ@ `�� � "� 6�ST_NUMINTERIORRINGS ST_NumInteriorRing(poly), ST_NumInteriorRings(poly)
Returns the number of interior rings in the Polygon value poly.
URL: http://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 |
+---------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html p} c��_� S��G� A @ B �~E� 9m� 86
infimum supremumA8���@ � � "� 6�JSON_KEYS 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: http://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"] |
+----------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-search-functions.htmlC��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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html< �@ � � "� 6
SHOW SLAVE HOSTS Syntax:
SHOW SLAVE HOSTS
Displays a list of replication slaves currently registered with the
master.
SHOW SLAVE HOSTS should be executed on a server that acts as a
replication master. The statement displays information about servers
that are or have been connected as replication slaves, with each row of
the result corresponding to one slave 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 slave server, as configured in
the slave server's option file, or on the command line with
--server-id=value.
o Host: The host name of the slave server as specified on the slave
with the --report-host option. This can differ from the machine name
as configured in the operating system.
o User: The slave server user name as, specified on the slave with the
--report-user option. Statement output includes this column only if
the master server is started with the --show-slave-auth-info option.
o Password: The slave server password as, specified on the slave with
the --report-password option. Statement output includes this column
only if the master server is started with the --show-slave-auth-info
option.
o Port: The port on the master to which the slave server is listening,
as specified on the slave with the --report-port option.
A zero in this column means that the slave port (--report-port) was
not set.
o Master_id: The unique server ID of the master server that the slave
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 slave, as generated on the
slave and found in the slave's auto.cnf file.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-slave-hosts.html
http://dev.mysql.com/doc/refman/5.7/en/show-slave-hosts.html2 ��@ (� � "� 6START 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 as
soon as you execute a statement that updates (modifies) a table, MySQL
stores the update on disk to make it permanent. The change cannot be
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
http://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
http://dev.mysql.com/doc/refman/5.7/en/innodb-performance-ro-txn.html
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 ISOLATION].
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
http://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
http://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
http://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 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: http://dev.mysql.com/doc/refman/5.7/en/commit.html
http://dev.mysql.com/doc/refman/5.7/en/commit.htmlCW/�@ 0& � "� 6'TIME_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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html; ��@ 8R � "� 64CREATE DATABASE (Syntax:
CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
[create_specification] ...
create_specification:
[DEFAULT] CHARACTER SET [=] charset_name
| [DEFAULT] 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: http://dev.mysql.com/doc/refman/5.7/en/create-database.html
http://dev.mysql.com/doc/refman/5.7/en/create-database.html> ~�@ @ � "� 6AVAR_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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html<р��@ H � "� 6NCONCAT_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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@ -�@ P� � "� 6[TEXT 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html9#��@ X�: � "� 6h~ Syntax:
~
Invert all bits.
The result is an unsigned 64-bit integer.
URL: http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 5 & ~1;
-> 4
http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html p5 c�G� �~�V� B A C i�E� ;ƀ 9�
infimum supremumB �ɀ@ u � "� 6uASIN 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: http://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' |
+---------+------+-----------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlAȁ��@
� "� 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 INFILE.
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() 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() C API function and the row count that the mysql
client displays following statement execution.
URL: http://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)
http://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlU��D�@ � � "� 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() and MBRCovers() handle their arguments and return a
value as follows:
o Return NULL if either argument is NULL or an empty geometry
o Return ER_GIS_INVALID_DATA if either argument is not a valid geometry
byte string (SRID plus WKB value)
o Otherwise, return non-NULL
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.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 |
+--------------------+-----------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.htmlBqÀ@ (� � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlA ��@ 03 � "� 6�FLOAT 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.
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
http://dev.mysql.com/doc/refman/5.7/en/no-matching-rows.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.htmlA����@ 8� � "� 6�CHARSET Syntax:
CHARSET(str)
Returns the character set of the string argument.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlK ���@ @O � "� 6�ASYMMETRIC_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: http://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);
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlC �@ H� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlAÃ �@ P
} � "� 6�JSON_CONTAINS JSON_CONTAINS(json_doc, val[, path])
Returns 0 or 1 to indicate whether a specific value is contained in a
target JSON document, or, if a path argument is given, at a specific
path within the target document. Returns NULL if any argument is NULL
or the path argument does not identify a section of the target
document. An error occurs if either document argument is not a valid
JSON document or 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: http://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 |
+-------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-search-functions.htmlC5��@ Xv � "� 6�DAYOFYEAR Syntax:
DAYOFYEAR(date)
Returns the day of the year for date, in the range 1 to 366.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYOFYEAR('2007-02-03');
-> 34
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html@ #�@ `� � "� 6�% 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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.htmlK ߀@ h� � "� 6ASTEXT !AsText(g), AsWKT(g)
ST_AsText(), ST_AsWKT(), AsText(), and AsWKT() are synonyms. For more
information, see the description of ST_AsText().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-format-conversion-functions.html= ��@ p% � "� 6DECLARE 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
http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.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
http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html.
Condition names referred to in SIGNAL or use RESIGNAL statements must
be associated with SQLSTATE values, not MySQL error codes.
URL: http://dev.mysql.com/doc/refman/5.7/en/declare-condition.html
http://dev.mysql.com/doc/refman/5.7/en/declare-condition.htmlC=.�@ xƫ � "� 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
(http://dev.mysql.com/doc/refman/5.7/en/locale-support.html).
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT MONTHNAME('2008-02-03');
-> 'February'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p �� c�V� i�dӕj C B F � E� 8�� 6� infimum supremumU �@ � � "� 6+NUMGEOMETRIES NumGeometries(gc)
ST_NumGeometries() and NumGeometries() are synonyms. For more
information, see the description of ST_NumGeometries().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.html< �@ � � "� 68CHANGE MASTER TO D & L�http://dev.mysql.com/doc/refman/5.7/en/change-master-to.htmlC��o�@ � � "� 6ETIMESTAMP 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html9 &�@ (� � "� 6RDROP 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, user privileges on the database are not
automatically dropped. See [HELP GRANT].
IF EXISTS is used to prevent an error from occurring if the database
does not exist.
URL: http://dev.mysql.com/doc/refman/5.7/en/drop-database.html
http://dev.mysql.com/doc/refman/5.7/en/drop-database.html7 ��@ 0 $ � "� 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. SHOW GRANTS requires the SELECT
privilege for the mysql database, except to see the privileges for the
current user.
For output that includes an IDENTIFIED BY PASSWORD clause displaying an
account password hash value, the SUPER privilege is required to see the
actual hash value. Otherwise, the value displays as <secret>.
To name the account, use the same format as for the GRANT statement;
for example, 'jeffrey'@'localhost'. If you specify only the user name
part of the account name, a host name part of '%' is used. For
additional information about specifying account names, see [HELP
GRANT].
mysql> SHOW GRANTS FOR 'root'@'localhost';
+---------------------------------------------------------------------+
| Grants for root@localhost |
+---------------------------------------------------------------------+
| GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION |
+---------------------------------------------------------------------+
To display the privileges granted to the account that 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 of the equivalent syntaxes) is
used in DEFINER context, such as within a stored procedure that is
defined with SQL SECURITY DEFINER), the grants displayed are those of
the definer and not the invoker.
SHOW GRANTS displays only the privileges granted explicitly to the
named account. Other privileges that might be available to the account
are not displayed. For example, if an anonymous account exists, the
named account might be able to use its privileges, but SHOW GRANTS will
not display them.
As of MySQL 5.7.6, SHOW GRANTS output does not include IDENTIFIED BY
PASSWORD clauses. Use the SHOW CREATE USER statement instead. See [HELP
SHOW CREATE USER].
URL: http://dev.mysql.com/doc/refman/5.7/en/show-grants.html
http://dev.mysql.com/doc/refman/5.7/en/show-grants.htmlA�� �@ 8A � "� 6lJSON_CONTAINS_PATH 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: http://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 |
+----------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html= �@ @� � "� 6yST_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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlBh3�@ H: � "� 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: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT CRC32('MySQL');
-> 3259397556
mysql> SELECT CRC32('mysql');
-> 2501908538
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlM Ҁ@ P| � "� 6�STARTPOINT
StartPoint(ls)
ST_StartPoint() and StartPoint() are synonyms. For more information,
see the description of ST_StartPoint().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlB ��@ X � "� 6�DECLARE 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
http://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
http://dev.mysql.com/doc/refman/5.7/en/local-variable-scope.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/declare-local-variable.html
http://dev.mysql.com/doc/refman/5.7/en/declare-local-variable.html= .�@ `� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html@ ��@ h? � "� 6�NOT BETWEEN Syntax:
expr NOT BETWEEN min AND max
This is the same as NOT (expr BETWEEN min AND max).
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlC8߁@ p� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT YEARWEEK('1987-01-01');
-> 198652
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html> �@ x� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlB���@ �4 � "� 6�LOG10 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 (as of MySQL 5.7.4) a warning
"Invalid argument for logarithm" is reported.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlA @ �v � "� 6�DECIMAL 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.
UNSIGNED, if specified, disallows negative values.
All basic calculations (+, -, *, /) with DECIMAL columns are done with
a precision of 65 digits.
URL: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html; V�@ �� � "� 6�CREATE FUNCTION (The CREATE FUNCTION statement is used to create stored functions and
user-defined functions (UDFs):
o For information about creating stored functions, see [HELP CREATE
PROCEDURE].
o For information about creating user-defined functions, see [HELP
CREATE FUNCTION UDF].
URL: http://dev.mysql.com/doc/refman/5.7/en/create-function.html
http://dev.mysql.com/doc/refman/5.7/en/create-function.html@"^@ � � "� 6< Syntax:
<
Less than:
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 < 2;
-> 0
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html@Lā@ �� � "� 6MD5 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 nonbinary string in the connection character set.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT MD5('testing');
-> 'ae2b1fca515949e5d54fb22b8ed95575'
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlC5�@ �ɉ � "� 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYOFMONTH('2007-02-03');
-> 3
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p-�%�;{ cdӕj � �q� D {
?� ESyntax:
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 = 'master_log_name'
| MASTER_LOG_POS = master_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 slave server uses for
connecting to the master server, for reading the master binary log, and
reading the slave relay log. It also updates the contents of the master
info and relay log info repositories (see
http://dev.mysql.com/doc/refman/5.7/en/slave-logs.html). CHANGE MASTER
TO requires the SUPER privilege.
Prior to MySQL 5.7.4, the slave 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
slave without doing this, depending on the states of the slave SQL
thread and slave I/O thread. The rules governing such use are provided
later in this section.
When using a multi-threaded slave (in other words
slave_parallel_workers is greater than 0), stopping the slave can cause
"gaps" in the sequence of transactions that have been executed from the
relay log, regardless of whether the slave 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 added in MySQL 5.7.6 enables
you to choose which replication channel the statement applies to. If no
clause is set and no extra channels exist, the statement applies to the
default channel and behaves the same as versions of MySQL prior to
5.7.6. 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_NAME=host1, MASTER_PORT=3002 FOR CHANNEL channel2
When using multiple replication channels, if a CHANGE MASTER TO
statement does not have a channel defined using a FOR CHANNEL channel
clause an error is generated. See
http://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 MySQL master has changed, issue this statement to tell the slave
about the new password:
CHANGE MASTER TO MASTER_PASSWORD='new3cret';
MASTER_HOST, MASTER_USER, MASTER_PASSWORD, and MASTER_PORT provide
information to the slave about how to connect to its master:
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 master MySQL server using TCP/IP.
If you specify the MASTER_HOST or MASTER_PORT option, the slave
assumes that the master server is different from before (even if the
option value is the same as its current value.) In this case, the old
values for the master 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. (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 master.
MASTER_USER cannot be made empty; setting MASTER_USER = '' or leaving
it unset when setting a value for MASTER_PASSWORD causes an error
(Bug #13427949).
The password used for a MySQL Replication slave 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)
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.)
The MASTER_SSL_xxx options provide information about using SSL for the
connection. They correspond to the --ssl-xxx options described in
http://dev.mysql.com/doc/refman/5.7/en/secure-connection-options.html,
and
http://dev.mysql.com/doc/refman/5.7/en/replication-solutions-secure-con
nections.html. These options can be changed even on slaves that are
compiled without SSL support. They are saved to the master info
repository, but are ignored if the slave does not have SSL support
enabled.
As of MySQL 5.7.3, the MASTER_SSL=1 is prescriptive, not advisory. When
given, the slave connection to the master must use SSL or the
connection attempt fails. Before 5.7.3, an SSL connection is permitted
but not required. This is analogous to the client-side meaning of the
--ssl command-line option; see
http://dev.mysql.com/doc/refman/5.7/en/secure-connection-options.html.
The MASTER_TLS_VERSION option specifies the encryption protocols
permitted by the master for slave connections. The value is like that
for the tls_version system variable: A comma-separated list containing
one or more protocol names. The protocols that can be named for this
option depend on the SSL library used to compile MySQL. For details,
see
http://dev.mysql.com/doc/refman/5.7/en/secure-connection-protocols-ciph
ers.html. This option was added in MySQL 5.7.10.
MASTER_CONNECT_RETRY specifies how many seconds to wait between connect
retries. The default is 60.
MASTER_RETRY_COUNT limits the number of reconnection attempts and
updates the value of the Master_Retry_Count column in the output of
SHOW SLAVE STATUS. The default value is 24 * 3600 = 86400.
MASTER_RETRY_COUNT is intended to replace the older
--master-retry-count server option, and is now the preferred method for
setting this limit. You are encouraged not to rely on
--master-retry-count in new applications and, when upgrading to MySQL
5.7, to update any existing applications that rely on it, so that they
use CHANGE MASTER TO ... MASTER_RETRY_COUNT instead.
MASTER_DELAY specifies how many seconds behind the master the slave
must lag. An event received from the master is not executed until at
least interval seconds later than its execution on the master. 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
http://dev.mysql.com/doc/refman/5.7/en/replication-delayed.html.
In MySQL 5.7.4 and later, a CHANGE MASTER TO statement employing the
MASTER_DELAY option can be executed on a running slave when the slave
SQL thread is stopped.
MASTER_BIND is for use on replication slaves having multiple network
interfaces, and determines which of the slave's network interfaces is
chosen for connecting to the master.
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 slave status log tables (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 replication slave to a specific network interface
is also supported by MySQL Cluster.
MASTER_HEARTBEAT_PERIOD sets the interval in seconds between
replication heartbeats. Whenever the master's binary log is updated
with an event, the waiting period for the next heartbeat is reset.
interval is a decimal value having the range 0 to 4294967 seconds and a
resolution in milliseconds; the smallest nonzero value is 0.001.
Heartbeats are sent by the master only if there are no unsent events in
the binary log file for a period longer than interval.
Prior to MySQL 5.7.4, not including MASTER_HEARTBEAT_PERIOD caused
CHANGE MASTER TO to reset the heartbeat period (Slave_heartbeat_period)
to the default, and Slave_received_heartbeats to 0. (Bug #18185490)
If you are logging master connection information to tables,
MASTER_HEARTBEAT_PERIOD can be seen as the value of the Heartbeat
column of the mysql.slave_master_info table.
Setting interval to 0 disables heartbeats altogether. The default value
for interval is equal to the value of slave_net_timeout divided by 2.
Setting @@global.slave_net_timeout to a value less than that of the
current heartbeat interval results in a warning being issued. The
effect of issuing RESET SLAVE on the heartbeat interval is to reset it
to the default value.
MASTER_LOG_FILE and MASTER_LOG_POS are the coordinates at which the
slave I/O thread should begin reading from the master the next time the
thread starts. RELAY_LOG_FILE and RELAY_LOG_POS are the coordinates at
which the slave SQL thread should begin reading from the relay log the
next time the thread starts. If you specify either of MASTER_LOG_FILE
or MASTER_LOG_POS, you cannot specify RELAY_LOG_FILE or RELAY_LOG_POS.
If you specify either of MASTER_LOG_FILE or MASTER_LOG_POS, you also
cannot specify MASTER_AUTO_POSITION = 1 (described later in this
section). If neither of MASTER_LOG_FILE or MASTER_LOG_POS is specified,
the slave uses the last coordinates of the slave SQL thread before
CHANGE MASTER TO was issued. This ensures that there is no
discontinuity in replication, even if the slave SQL thread was late
compared to the slave I/O thread, when you merely want to change, say,
the password to use.
In MySQL 5.7.4 and later, a CHANGE MASTER TO statement employing
RELAY_LOG_FILE, RELAY_LOG_POS, or both options can be executed on a
running slave when the slave SQL thread is stopped.
If MASTER_AUTO_POSITION = 1 is used with CHANGE MASTER TO, the slave
attempts to connect to the master using the GTID-based replication
protocol. In MySQL 5.7.4 and later, this option can be employed by
CHANGE MASTER TO only if both the slave SQL and slave I/O threads are
stopped.
When using GTIDs, the slave tells the master which transactions it has
already received, executed, or both. To compute this set, it reads the
global value of gtid_executed and the value of the Retrieved_gtid_set
column from SHOW SLAVE STATUS. The GTID of the last transmitted
transaction is included in Retrieved_gtid_set only when the full
transaction is received. The slave computes the following set:
UNION(@@global.gtid_executed, Retrieved_gtid_set)
Prior to MySQL 5.7.5, the GTID of the last transmitted transaction was
included in Retrieved_gtid_set even if the transaction was only
partially transmitted, and the last received GTID was subtracted from
this set. (Bug #17943188) Thus, the slave computed the following set:
UNION(@@global.gtid_executed, Retrieved_gtid_set - last_received_GTID)
This set is sent to the master as part of the initial handshake, and
the master sends back all transactions that it has executed which are
not part of the set. If any of these transactions have been already
purged from the master's binary log, the master sends the error
ER_MASTER_HAS_PURGED_REQUIRED_GTIDS to the slave, and replication does
not start.
When GTID-based replication is employed, the coordinates represented by
MASTER_LOG_FILE and MASTER_LOG_POS are not used, and global transaction
identifiers are used instead. Thus the use of either or both of these
options together with MASTER_AUTO_POSITION causes an error.
Beginning with MySQL 5.7.1, you can see whether replication is running
with autopositioning enabled by checking the output of SHOW SLAVE
STATUS. (Bug #15992220)
gtid_mode must also be enabled before issuing CHANGE MASTER TO ...
MASTER_AUTO_POSITION = 1. Otherwise, the statement fails with an error.
To revert to the older file-based replication protocol after using
GTIDs, you can issue a new CHANGE MASTER TO statement that specifies
MASTER_AUTO_POSITION = 0, as well as at least one of MASTER_LOG_FILE or
MASTER_LOG_POS.
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 when neither the slave SQL thread nor the slave I/O thread is
stopped; if both threads are stopped, all relay log files are deleted
unless you at least one of RELAY_LOG_FILE or RELAY_LOG_POS is
specified.
RELAY_LOG_FILE can use either an absolute or relative path, and uses
the same base name as MASTER_LOG_FILE. (Bug #12190)
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 master 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.
In MySQL 5.7, the master info repository and the output of SHOW SLAVE
STATUS provide the list of servers that are currently ignored. For more
information, see
http://dev.mysql.com/doc/refman/5.7/en/slave-logs-status.html, and
[HELP SHOW SLAVE STATUS].
In MySQL 5.7, 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
slave's state prior to execution.
In MySQL 5.7, CHANGE MASTER TO causes an implicit commit of an ongoing
transaction. See
http://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
In MySQL 5.7.4 an�q� {]h� E {
�����d 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 slave is
stopped, the behavior of CHANGE MASTER TO depends (in MySQL 5.7.4 and
later) on the states of the slave SQL thread and slave I/O threads;
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 slave 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, or MASTER_DELAY, even when the
SQL thread is running. These three options may not be used when the
I/O 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 slave SQL and I/O threads using
SHOW SLAVE STATUS.
For more information, see
http://dev.mysql.com/doc/refman/5.7/en/replication-solutions-switch.htm
l.
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 slave. In MySQL 5.7.4
and later, a warning (ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO) is now
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 slave when you have the
snapshot of the master and have recorded the master binary log
coordinates corresponding to the time of the snapshot. After loading
the snapshot into the slave to synchronize it with the master, you can
run CHANGE MASTER TO MASTER_LOG_FILE='log_name', MASTER_LOG_POS=log_pos
on the slave to specify the coordinates at which the slave should begin
reading the master binary log.
The following example changes the master server the slave uses and
establishes the master binary log coordinates from which the slave
begins reading. This is used when you want to set up the slave to
replicate the master:
CHANGE MASTER TO
MASTER_HOST='master2.mycompany.com',
MASTER_USER='replication',
MASTER_PASSWORD='bigs3cret',
MASTER_PORT=3306,
MASTER_LOG_FILE='master2-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 slave has relay log files that you want it to
execute again for some reason. To do this, the master 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='slave-relay-bin.006',
RELAY_LOG_POS=4025;
URL: http://dev.mysql.com/doc/refman/5.7/en/change-master-to.html
]h� {hn\� F C G ��E� :�� 8r infimum supremumCԀ߃@ T � "� 6/UNIX_TIMESTAMP Syntax:
UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)
If called with no argument, returns a Unix timestamp (seconds since
'1970-01-01 00:00:00' UTC). 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.
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
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 server interprets date as a value in the current time
zone and converts it to an internal value in UTC. Clients can set their
time zone as described in
http://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlFu�ǀ@ � � "� 6<ST_INTERSECTION ST_Intersection(g1, g2)
Returns a geometry that represents the point set intersection of the
geometry values g1 and g2.
URL: http://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) |
+--------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html7 g�@ � � "� 6IRENAME 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 database. When the read_only system
variable is enabled, RENAME USER additionally requires the SUPER
privilege.
Each account name uses the format described in
http://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
http://dev.mysql.com/doc/refman/5.7/en/stored-programs-security.html.)
The privilege changes take effect as indicated in
http://dev.mysql.com/doc/refman/5.7/en/privilege-changes.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/rename-user.html
http://dev.mysql.com/doc/refman/5.7/en/rename-user.htmlM @ (x � "� 6VNUMPOINTS
NumPoints(ls)
ST_NumPoints() and NumPoints() are synonyms. For more information, see
the description of ST_NumPoints().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.html? ��@ 0F � "� 6cALTER 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 MySQL 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: http://dev.mysql.com/doc/refman/5.7/en/alter-logfile-group.html
http://dev.mysql.com/doc/refman/5.7/en/alter-logfile-group.htmlC ��@ 8V � "� 6pLOCALTIMESTAMP Syntax:
LOCALTIMESTAMP, LOCALTIMESTAMP([fsp])
LOCALTIMESTAMP and LOCALTIMESTAMP() are synonyms for NOW().
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlCA��@ @t � "� 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 the discussion for DATE_ADD().
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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT ADDDATE('2008-01-02', 31);
-> '2008-02-02'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlK:a�@ HD � "� 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: http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
SET @dig = CREATE_DIGEST('SHA512', The quick brown fox');
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.htmlA����@ P � � "� 6�-> 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 on the right that is evaluated
against the JSON document (the column value). You can use such
expressions in place of column identifiers wherever they occur in SQL
statements.
URL: http://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)
http://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html: ��@ XC � "� 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
http://dev.mysql.com/doc/refman/5.7/en/stored-programs-logging.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/alter-function.html
http://dev.mysql.com/doc/refman/5.7/en/alter-function.html> 7�@ `� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/deallocate-prepare.html
http://dev.mysql.com/doc/refman/5.7/en/deallocate-prepare.htmlC >�@ h� � "� 6�IS_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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlF ʀ@ pm � "� 6�CONVEXHULL ConvexHull(g)
ST_ConvexHull() and ConvexHull() are synonyms. For more information,
see the description of ST_ConvexHull().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlT р@ x� � "� 6�TOUCHES Touches(g1, g2)
ST_Touches() and Touches() are synonyms. For more information, see the
description of ST_Touches().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlB����@ �6 � "� 6�AUTO_INCREMENT The AUTO_INCREMENT attribute can be used to generate a unique identity
for new rows:
URL: http://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;
http://dev.mysql.com/doc/refman/5.7/en/example-auto-increment.html@��v�@ �� � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html p1n 9� chn\� ��� G F H ?%E� :�� 8w infimum supremum= b�@ � � "� 6�GEOMCOLLFROMTEXT 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.htmlJ��݀@ = � "� 6 ST_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.
URL: http://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) |
+-------------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.htmlA g�@
� "� 6LAST_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() will remain
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.
Prior to MySQL 5.7.3, this function was not replicated correctly if
replication filtering rules were in use. (Bug #17234370, Bug #69861)
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 following statements
will not see a changed value.
URL: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
http://dev.mysql.com/doc/refman/5.7/en/information-functions.htmlB:��@ (k � "� 6&FLOOR Syntax:
FLOOR(X)
Returns the largest integer value not greater than X.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT FLOOR(1.23), FLOOR(-1.23);
-> 1, -2
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlB'��@ 0V � "� 63COS Syntax:
COS(X)
Returns the cosine of X, where X is given in radians.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT COS(PI());
-> -1
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html> "�@ 8� � "� 6@STD Syntax:
STD(expr)
Returns the population standard deviation of expr. This is an extension
to standard SQL. The standard SQL function STDDEV_POP() can be used
instead.
If there are no matching rows, STD() returns NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlCC��@ @� � "� 6MDATE FUNCTION Syntax:
DATE(expr)
Extracts the date part of the date or datetime expression expr.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlBo��@ H� � "� 6ZTAN Syntax:
TAN(X)
Returns the tangent of X, where X is given in radians.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlC5��@ P� � "� 6gWEEKOFYEAR 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT WEEKOFYEAR('2008-02-20');
-> 8
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlFk�^�@ Xm � "� 6tST_CONVEXHULL ST_ConvexHull(g)
Returns a geometry that represents the convex hull of the geometry
value g.
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: http://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)) |
+-----------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-operator-functions.htmlCɀ�@ `n � "� 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlBS
�@ h� � "� 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 (as of MySQL 5.7.4) a warning "Invalid
argument for logarithm" is reported.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT LOG2(65536);
-> 16
mysql> SELECT LOG2(-100);
-> NULL
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html@KÀ@ p� � "� 6�UNCOMPRESSED_LENGTH Syntax:
UNCOMPRESSED_LENGTH(compressed_string)
Returns the length that the compressed string had before being
compressed.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
-> 30
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlBN��@ xz � "� 6�POW Syntax:
POW(X,Y)
Returns the value of X raised to the power of Y.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT POW(2,2);
-> 4
mysql> SELECT POW(2,-2);
-> 0.25
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html6 (�@ �� � "� 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. All table data and the table definition are removed, so
be careful with this statement! If any of the tables named in the
argument list do not exist, MySQL returns an error indicating by name
which nonexisting tables it was unable to drop, but it also drops all
of the tables in the list that do exist.
*Important*:
When a table is dropped, user privileges on the table are not
automatically dropped. See [HELP GRANT].
For a partitioned table, DROP TABLE permanently removes the table
definition, all of its partitions, and all of the data which was stored
in those partitions. It also removes partition definitions associated
with the dropped table.
*Note*:
Prior to MySQL 5.7.6, DROP TABLE removes partition definitions (.par)
files associated with the dropped table. As of MySQL 5.7.6, partition
definition (.par) files are no longer created. Instead, partition
definitions are stored in the internal data dictionary.
Use IF EXISTS to prevent an error from occurring for tables that do not
exist. A NOTE is generated for each nonexistent table when using IF
EXISTS. See [HELP SHOW WARNINGS].
IF EXISTS can 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.)
RESTRICT and CASCADE are permitted to make porting easier. In MySQL
5.7, they do nothing.
*Note*:
DROP TABLE automatically commits the current active transaction, unless
you use the TEMPORARY keyword.
URL: http://dev.mysql.com/doc/refman/5.7/en/drop-table.html
http://dev.mysql.com/doc/refman/5.7/en/drop-table.htmlCp@ �� � "� 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
a string or numeric context. The value is expressed in the current 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html8 ��@ �H � "� 6�SHOW 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. This
information can also be obtained from the INFORMATION_SCHEMA ENGINES
table. See http://dev.mysql.com/doc/refman/5.7/en/engines-table.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-engines.html
http://dev.mysql.com/doc/refman/5.7/en/show-engines.html= '�@ �� � "� 6�ST_POINTFROMTEXT ST_PointFromText(wkt[, srid])
Constructs a Point value using its WKT representation and SRID.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.htmlM]���@ �� � "� 6�ST_ENDPOINT
ST_EndPoint(ls)
Returns the Point that is the endpoint of the LineString value ls.
URL: http://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) |
+----------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlCC�@ �� � "� 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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT IS_IPV6('10.0.5.9'), IS_IPV6('::1');
-> 0, 1
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html@ ��@ �� � "� 6LONGBLOB 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html p,� �� c�� ?%^� H G I s�E� 2� 0{ infimum supremumT 9�@ � � "� 6ST_OVERLAPS ST_Overlaps(g1, g2)
Returns 1 or 0 to indicate whether g1 spatially overlaps g2. The term
spatially overlaps is used if two geometries intersect and their
intersection results in a geometry of the same dimension but not equal
to either of the given geometries.
As of MySQL 5.7.5, 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlG u�@ � "� 6 YEAR DATA TYPE YEAR[(4)]
A year in four-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, and 0000.
*Note*:
The YEAR(2) data type is deprecated and support for it is removed in
MySQL 5.7.5. To convert YEAR(2) columns to YEAR(4), see
http://dev.mysql.com/doc/refman/5.7/en/migrating-to-year4.html.
For additional information about YEAR display format and interpretation
of input values, see http://dev.mysql.com/doc/refman/5.7/en/year.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.html> .�@ � � "� 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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlG ��@ (
� � "� 67JSON_SET JSON_SET(json_doc, path, val[, path, val] ...)
Inserts or updates data in a JSON document and returns the result.
Returns NULL if any argument is NULL 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 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: http://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]} |
+-----------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html<?��@ 0� � "� 6DREPEAT 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT REPEAT('MySQL', 3);
-> 'MySQLMySQLMySQL'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html<n�@ 8
� "� 6QSOUNDEX &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.
We hope to remove these limitations in a future release. See Bug
#22638 for more information.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT SOUNDEX('Hello');
-> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
-> 'Q36324'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlU ��@ @H � "� 6^MBRTOUCHES MBRTouches(g1, g2)
Returns 1 or 0 to indicate whether the minimum bounding rectangles of
the two geometries g1 and g2 touch. Two geometries spatially touch if
the interiors of the geometries do not intersect, but the boundary of
one of the geometries intersects either the boundary or the interior of
the other.
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html6 *�@ H� � "� 6kDROP 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: http://dev.mysql.com/doc/refman/5.7/en/drop-event.html
http://dev.mysql.com/doc/refman/5.7/en/drop-event.html@ �@ P� � "� 6xVARBINARY 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html6 ��@ X � "� 6�LOAD INDEX Syntax:
LOAD INDEX INTO CACHE
tbl_index_list [, tbl_index_list] ...
tbl_index_list:
tbl_name
[PARTITION (partition_list | ALL)]
[[INDEX|KEY] (index_name[, index_name] ...)]
[IGNORE LEAVES]
partition_list:
partition_name[, partition_name][, ...]
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 is used only for MyISAM tables. In MySQL 5.7, it
is also supported for 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: http://dev.mysql.com/doc/refman/5.7/en/load-index.html
http://dev.mysql.com/doc/refman/5.7/en/load-index.html1 V�@ `� � "� 6�UNION Syntax:
SELECT ...
UNION [ALL | DISTINCT] SELECT ...
[UNION [ALL | DISTINCT] SELECT ...]
UNION is used to combine the result from multiple SELECT statements
into a single result set.
The column names from the first SELECT statement are used as the column
names for the results returned. 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.)
URL: http://dev.mysql.com/doc/refman/5.7/en/union.html
http://dev.mysql.com/doc/refman/5.7/en/union.htmlCh��@ h� � "� 6�TO_DAYS Syntax:
TO_DAYS(date)
Given a date date, returns a day number (the number of days since year
0).
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html6 ��@ p� � "� 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.
You can use db_name.tbl_name as an alternative to the tbl_name FROM
db_name syntax. 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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
You can also list a table's indexes with the mysqlshow -k db_name
tbl_name command.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-index.html
http://dev.mysql.com/doc/refman/5.7/en/show-index.html@��g�@ x� � "� 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: http://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 */
http://dev.mysql.com/doc/refman/5.7/en/show-create-database.html=����@ �� � "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/logical-operators.html p 'O c^� s��j� I H J �SE� %x� $5 infimum supremum;g��@ � "� 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
http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.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
http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.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
http://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 http://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: http://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)
http://dev.mysql.com/doc/refman/5.7/en/declare-handler.htmlA �@ � � "� 6�DOUBLE 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.
UNSIGNED, if specified, disallows negative values.
URL: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.htmlG �@ � � "� 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-overview.htmlA ��@ (% � "� 6�SYSTEM_USER Syntax:
SYSTEM_USER()
SYSTEM_USER() is a synonym for USER().
URL: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html: ��@ 0 A � "� 6 TRUNCATE 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 in MySQL 5.7:
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.
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.
*Note*:
As of MySQL 5.7.6, partition definition (.par) files are no longer
created. Instead, partition definitions are stored in the internal
data dictionary.
o The TRUNCATE TABLE statement does not invoke ON DELETE triggers.
URL: http://dev.mysql.com/doc/refman/5.7/en/truncate-table.html
http://dev.mysql.com/doc/refman/5.7/en/truncate-table.htmlC ��@ 8�; � "� 6 CURRENT_DATE Syntax:
CURRENT_DATE, CURRENT_DATE()
CURRENT_DATE and CURRENT_DATE() are synonyms for CURDATE().
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p c�j� �S��t J I K ��E� 8� 7� infimum supremum7
�@ � � "� 6 !START SLAVE 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 with no thread_type options starts both of the slave
threads. The I/O thread reads events from the master server and stores
them in the relay log. The SQL thread reads events from the relay log
and executes them. START SLAVE requires the SUPER privilege.
If START SLAVE succeeds in starting the slave threads, it returns
without any error. However, even in that case, it might be that the
slave threads start and then later stop (for example, because they do
not manage to connect to the master or read its binary log, or some
other problem). START SLAVE does not warn you about this. You must
check the slave's error log for error messages generated by the slave
threads, or check that they are running satisfactorily with SHOW SLAVE
STATUS.
In MySQL 5.7, START SLAVE causes an implicit commit of an ongoing
transaction. See
http://dev.mysql.com/doc/refman/5.7/en/implicit-commit.html.
Beginning with MySQL 5.7.1, gtid_next must be set to AUTOMATIC before
issuing this statement (Bug #16062608).
The optional FOR CHANNEL channel clause added in MySQL 5.7.6 enables
you to choose which replication channel the statement applies to. If no
clause is set and no extra channels exist, the statement applies to the
default channel and behaves the same as versions of MySQL prior to
5.7.6. Providing a FOR CHANNEL channel clause applies the START SLAVE
statement to a specific replication 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. Beginning with
MySQL 5.7.9, this statement is disallowed for the
group_replication_recovery channel. See
http://dev.mysql.com/doc/refman/5.7/en/replication-channels.html for
more information.
MySQL 5.7 supports pluggable user-password authentication with START
SLAVE with the USER, PASSWORD, DEFAULT_AUTH and PLUGIN_DIR options, as
described in the following list:
o USER: User name. Cannot be set to an empty or null string, or left
unset if PASSWORD is used.
o PASSWORD: Password.
o DEFAULT_AUTH: Name of plugin; default is MySQL native authentication.
o PLUGIN_DIR: Location of plugin.
You cannot use the SQL_THREAD option when specifying any of USER,
PASSWORD, DEFAULT_AUTH, or PLUGIN_DIR, unless the IO_THREAD option is
also provided.
See
http://dev.mysql.com/doc/refman/5.7/en/pluggable-authentication.html,
for more information.
If an insecure connection is used with any these options, the server
issues the warning Sending passwords in plain text without SSL/TLS is
extremely insecure.
START SLAVE ... UNTIL supports two additional options for use with
global transaction identifiers (GTIDs) (see
http://dev.mysql.com/doc/refman/5.7/en/replication-gtids.html). Each of
these takes a set of one or more global transaction identifiers
gtid_set as an argument (see
http://dev.mysql.com/doc/refman/5.7/en/replication-gtids-concepts.html#
replication-gtids-concepts-gtid-sets, for more information).
When no thread_type is specified, START SLAVE UNTIL SQL_BEFORE_GTIDS
causes the slave SQL thread to process transactions until it has
reached the first transaction whose GTID is listed in the gtid_set.
START SLAVE UNTIL SQL_AFTER_GTIDS causes the slave threads to process
all transactions until the last transaction in the gtid_set has been
processed by both threads. In other words, START SLAVE UNTIL
SQL_BEFORE_GTIDS causes the slave SQL thread to process all
transactions occurring before the first GTID in the gtid_set is
reached, and START SLAVE UNTIL SQL_AFTER_GTIDS causes the slave threads
to handle all transactions, including those whose GTIDs are found in
gtid_set, until each has encountered a transaction whose GTID is not
part of the set. SQL_BEFORE_GTIDS and SQL_AFTER_GTIDS each support the
SQL_THREAD and IO_THREAD options, although using IO_THREAD with them
currently has no effect.
For example, START SLAVE SQL_THREAD UNTIL SQL_BEFORE_GTIDS =
3E11FA47-71CA-11E1-9E33-C80AA9429562:11-56 causes the slave SQL thread
to process all transactions originating from the master whose
server_uuid is 3E11FA47-71CA-11E1-9E33-C80AA9429562 until it encounters
the transaction having sequence number 11; it then stops without
processing this transaction. In other words, all transactions up to and
including the transaction with sequence number 10 are processed.
Executing START SLAVE SQL_THREAD UNTIL SQL_AFTER_GTIDS =
3E11FA47-71CA-11E1-9E33-C80AA9429562:11-56, on the other hand, would
cause the slave SQL thread to obtain all transactions just mentioned
from the master, including all of the transactions having the sequence
numbers 11 through 56, and then to stop without processing any
additional transactions; that is, the transaction having sequence
number 56 would be the last transaction fetched by the slave SQL
thread.
Prior to MySQL 5.7.3, SQL_AFTER_GTIDS did not stop the slave once the
indicated transaction was completed, but waited until another GTID
event was received (Bug #14767986).
When using a multi-threaded slave, there is a chance of gaps in the
sequence of transactions that have been executed from the relay log in
the following cases:
o killing the coordinator thread
o after an error occurs in the worker threads
o mysqld shuts down unexpectedly
Use the START SLAVE UNTIL SQL_AFTER_MTS_GAPS statement to cause a
multi-threaded slave's worker threads to only run until no more gaps
are found in the relay log, and then to stop. This statement can take
an SQL_THREAD option, but the effects of the statement remain
unchanged. It has no effect on the slave I/O thread (and cannot be used
with the IO_THREAD option).
Issuing START SLAVE on a multi-threaded slave with gaps in the sequence
of transactions executed from the relay log generates a warning. In
such a situation, the solution is to use START SLAVE UNTIL
SQL_AFTER_MTS_GAPS, then issue RESET SLAVE to remove any remaining
relay logs. See
http://dev.mysql.com/doc/refman/5.7/en/replication-features-transaction
-inconsistencies.html for more information.
To change a failed multi-threaded slave 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;
*Note*:
It is possible to view the entire text of a running START SLAVE ...
statement, including any USER or PASSWORD values used, in the output of
SHOW PROCESSLIST. This is also true for the text of a running CHANGE
MASTER TO statement, including any values it employs for MASTER_USER or
MASTER_PASSWORD.
URL: http://dev.mysql.com/doc/refman/5.7/en/start-slave.html
http://dev.mysql.com/doc/refman/5.7/en/start-slave.htmlJ ��@ ` � "� 6 .AREA Area(poly)
ST_Area() and Area() are synonyms. For more information, see the
description of ST_Area().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html9 �@ � � "� 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 INFILE 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
http://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
http://dev.mysql.com/doc/refman/5.7/en/explain-extended.html.
As of MySQL 5.7.2, 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).
Before MySQL 5.7.2, SHOW WARNINGS displays information about the
conditions resulting from the most recent statement in the current
session that generated messages. It shows nothing if the most recent
statement used a table and generated no messages. (That is, statements
that use a table but generate no messages clear the message list.)
Statements that do not use tables and do not generate messages have no
effect on the message list.
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, as of MySQL
5.7.2, 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: http://dev.mysql.com/doc/refman/5.7/en/show-warnings.html
http://dev.mysql.com/doc/refman/5.7/en/show-warnings.html= O�@ (� "� 6 HST_LINEFROMTEXT ST_LineFromText(wkt[, srid]), ST_LineStringFromText(wkt[, srid])
Constructs a LineString value using its WKT representation and SRID.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html5 ��@ 06 "� 6 UDROP 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 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.
As of MySQL 5.7.8, the IF EXISTS clause can be used, which causes the
statement to produce a warning for each named account that does not
exist, rather than an error.
Each account name uses the format described in
http://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: http://dev.mysql.com/doc/refman/5.7/en/drop-user.html
http://dev.mysql.com/doc/refman/5.7/en/drop-user.html<z�6�@ 8I "� 6 bSUBSTRING &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.
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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlJ @ @i "� 6 oISEMPTY %IsEmpty(g)
ST_IsEmpty() and IsEmpty() are synonyms. For more information, see the
description of ST_IsEmpty().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html@ ��@ H� "� 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: http://dev.mysql.com/doc/refman/5.7/en/show-function-status.html
http://dev.mysql.com/doc/refman/5.7/en/show-function-status.html<5��@ P�� "� 6 �LTRIM &Syntax:
LTRIM(str)
Returns the string str with leading space characters removed.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LTRIM(' barbar');
-> 'barbar'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html p)) c��t ��<KP K J L K)E� ; 9� infimum supremumT `�@ "� 6 �ST_CROSSES ST_Crosses(g1, g2)
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.
As of MySQL 5.7.5, 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.
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
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html= T�@ � "� 6 �ST_MPOLYFROMTEXT ST_MPolyFromText(wkt[, srid]), ST_MultiPolygonFromText(wkt[, srid])
Constructs a MultiPolygon value using its WKT representation and SRID.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html0 ��@ ; "� 6 �CALL 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()
function.
URL: http://dev.mysql.com/doc/refman/5.7/en/call.html
http://dev.mysql.com/doc/refman/5.7/en/call.htmlU ��@ (� "� 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: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mysql-specific.htmlCn��@ 0�
"� 6 �VALUES 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
http://dev.mysql.com/doc/refman/5.7/en/insert-on-duplicate.html.
URL: http://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);
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html@ {�@ 8 "� 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, will
be removed in a future MySQL release, and should no longer be used.
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.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html<���@ @ "� 6 �SUBSTRING_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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlH����@ H
"� 6 �ST_X ST_X(p)
Returns the X-coordinate value for the Point object p as a
double-precision number.
URL: http://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 |
+--------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-point-property-functions.htmlC�� �@ P[ "� 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlB"�2�@ X� "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html0 �@ `� "� 6 SHOW 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 [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 [NONBLOCKING]
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
http://dev.mysql.com/doc/refman/5.7/en/extended-show.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/show.html
http://dev.mysql.com/doc/refman/5.7/en/show.html: ��@ h
2 "� 6 %SHOW VARIABLES Syntax:
SHOW [GLOBAL | SESSION] VARIABLES
[LIKE 'pattern' | WHERE expr]
*Note*:
As of MySQL 5.7.6, 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
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
SHOW VARIABLES shows the values of MySQL system variables (see
http://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
http://dev.mysql.com/doc/refman/5.7/en/performance-schema-system-vari
able-tables.html.
o The GLOBAL_VARIABLES and SESSION_VARIABLES tables. See
http://dev.mysql.com/doc/refman/5.7/en/variables-table.html.
o The mysqladmin variables command. See
http://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
http://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 varaible
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
http://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
http://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: http://dev.mysql.com/doc/refman/5.7/en/show-variables.html
http://dev.mysql.com/doc/refman/5.7/en/show-variables.html2 ځ@ pi "� 6 2BINLOG 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 http://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: http://dev.mysql.com/doc/refman/5.7/en/binlog.html
http://dev.mysql.com/doc/refman/5.7/en/binlog.htmlT ˀ@ x| "� 6 ?ST_DISJOINT ST_Disjoint(g1, g2)
Returns 1 or 0 to indicate whether g1 is spatially disjoint from (does
not intersect) g2.
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.htmlBo0�@ �? "� 6 LATAN2 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html=��܀@ ��� "� 6 YAND 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/logical-operators.html p&L^ � c<KP K)��J� L K N ��E� 4�� 3R infimum supremumC^!�@ "� 6 fHOUR 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html2 ��@ 0 "� 6 sSELECT 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 ...]
[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 OUTFILE 'file_name'
[CHARACTER SET charset_name]
export_options
| INTO DUMPFILE 'file_name'
| INTO var_name [, var_name]]
[FOR UPDATE | LOCK IN SHARE MODE]]
SELECT is used to retrieve rows selected from one or more tables, and
can include UNION statements and subqueries. See [HELP UNION], and
http://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 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
http://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.
See
http://dev.mysql.com/doc/refman/5.7/en/partitioning-limitations-locki
ng.html, for more information.
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 (summary)
functions. See
http://dev.mysql.com/doc/refman/5.7/en/expressions.html, and
http://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: http://dev.mysql.com/doc/refman/5.7/en/select.html
http://dev.mysql.com/doc/refman/5.7/en/select.html>zÁ@ � "� 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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
mysql> SELECT student_name,
-> GROUP_CONCAT(test_score)
-> FROM student
-> GROUP BY student_name;
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.htmlAI�n�@ (U "� 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 always 0. The intended use is from
within the mysql client, which reports query execution times:
URL: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));
+----------------------------------------------+
| BENCHMARK(1000000,ENCODE('hello','goodbye')) |
+----------------------------------------------+
| 0 |
+----------------------------------------------+
1 row in set (4.74 sec)
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html<X{�@ 0l "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
-> 'JWJj', 'abc'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html7 �@ 8 � "� 6 �SHOW ENGINE M & %_http://dev.mysql.com/doc/refman/5.7/en/show-engine.htmlC 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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlC �@ H� "� 6 �RELEASE_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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlCm��@ P� "� 6 �WEEKDAY Syntax:
WEEKDAY(date)
Returns the weekday index for date (0 = Monday, 1 = Tuesday, ... 6 =
Sunday).
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlCo��@ X� "� 6 �TIME_TO_SEC Syntax:
TIME_TO_SEC(time)
Returns the time argument, converted to seconds.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlC��@ ` "� 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
http://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html. This
function returns NULL if the arguments are invalid.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html<���@ h ! "� 6 �EXPORT_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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html: 3�@ p� " "� 6 CAST &Syntax:
CAST(expr AS type)
The CAST() function takes an expression of any type and produces a
result value of the specified type, similar to CONVERT(). For more
information, see the description of CONVERT().
CAST() is standard SQL syntax.
URL: http://dev.mysql.com/doc/refman/5.7/en/cast-functions.html
http://dev.mysql.com/doc/refman/5.7/en/cast-functions.html< ��@ x3 # "� 6 SOUNDS LIKE &Syntax:
expr1 SOUNDS LIKE expr2
This is the same as SOUNDEX(expr1) = SOUNDEX(expr2).
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlC8�@ �� $ "� 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT PERIOD_DIFF(200802,200703);
-> 11
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html>l�@ � % "� 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: http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
mysql> SELECT student_name, AVG(test_score)
-> FROM student
-> GROUP BY student_name;
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html<`с@ �� & "� 6 6QUOTE &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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT QUOTE('Don\'t!');
-> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
-> NULL
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html@hF�@ �K ' "� 6 CIN Syntax:
expr IN (value,...)
Returns 1 if expr is equal to any of the values in the IN list, else
returns 0. If all values are constants, they are evaluated according to
the type of expr and sorted. The search for the item then is done using
a binary search. This means IN is very quick if the IN value list
consists entirely of constants. Otherwise, type conversion takes place
according to the rules described in
http://dev.mysql.com/doc/refman/5.7/en/type-conversion.html, but
applied to all the arguments.
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlC2��@ �� ( "� 6 PQUARTER Syntax:
QUARTER(date)
Returns the quarter of the year for date, in the range 1 to 4.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT QUARTER('2008-04-01');
-> 2
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html p":� c��J� ��2�c M s
%_����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
http://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
http://dev.mysql.com/doc/refman/5.7/en/monitor-innodb-mutex-waits-perfo
rmance-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 the following 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 will free 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 skips the mutexes and rw-locks of buffer pool
blocks, as the amount of output can be overwhelming on systems with a
large buffer pool. (There is one mutex and one rw-lock in each 16K
buffer pool block, and there are 65,536 blocks per gigabyte.) 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).
Some size and count attributes were named row_size and row_count before
MySQL 5.7.1.
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=192.168.0.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: http://dev.mysql.com/doc/refman/5.7/en/show-engine.html
2�c s��V� N L O �7E� ;�� /� infimum supremumB lj@
g ) "� 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/mysql-server-side-help.html
http://dev.mysql.com/doc/refman/5.7/en/mysql-server-side-help.htmlG��W�@ � * "� 6 jJSON_REPLACE 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: http://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]} |
+-----------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html< ��@ ; + "� 6 wPOSITION &Syntax:
POSITION(substr IN str)
POSITION(substr IN str) is a synonym for LOCATE(substr,str).
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlC �@ (� , "� 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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html= �@ 0� - "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.htmlJ[��@ 8� . "� 6 �ST_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: http://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 |
+-----------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html6 )�@ @� / "� 6 �ALTER USER
Syntax:
ALTER USER syntax for MySQL 5.7.6 and higher:
The ALTER USER statement modifies MySQL accounts. It provides control
over account password expiration. As of MySQL 5.7.6, it also provides
control over authentication, SSL/TLS, and resource-limit properties,
and account locking and unlocking.
To use ALTER USER, you must have the global CREATE USER privilege or
the UPDATE privilege for the mysql database. When the read_only system
variable is enabled, ALTER USER additionally requires the SUPER
privilege.
An error occurs if you try to modify an account that does not exist.
As of MySQL 5.7.8, the IF EXISTS clause can be used, which causes the
statement to produce a warning for each named account that does not
exist, rather than an error.
ALTER USER modifies the mysql.user table row for each affected account
according to the options specified in the statement. Unspecified
properties retain their current values.
Example 1: Change an account's password and expire it. As a result, the
user must connect with the named password and choose a new one at the
next connection:
ALTER USER 'jeffrey'@'localhost'
IDENTIFIED BY 'new_password' PASSWORD EXPIRE;
Example 2: Modify an account to use the sha256_password authentication
plugin and the given password. Require that a new password be chosen
every 180 days:
ALTER USER 'jeffrey'@'localhost'
IDENTIFIED WITH sha256_password BY 'new_password'
PASSWORD EXPIRE INTERVAL 180 DAY;
Example 3: Lock or unlock an account:
ALTER USER 'jeffrey'@'localhost' ACCOUNT LOCK;
ALTER USER 'jeffrey'@'localhost' ACCOUNT UNLOCK;
Example 4: Require an account to connect using SSL and establish a
limit of 20 connections per hour:
ALTER USER 'jeffrey'@'localhost'
REQUIRE SSL WITH MAX_CONNECTIONS_PER_HOUR 20;
URL: http://dev.mysql.com/doc/refman/5.7/en/alter-user.html
http://dev.mysql.com/doc/refman/5.7/en/alter-user.html@z��@ H
0 "� 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 http://dev.mysql.com/doc/refman/5.7/en/secure-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 as of
MySQL 5.7.6, will be removed in a future MySQL release, and should no
longer be used. Consider using AES_ENCRYPT() and AES_DECRYPT() instead.
URL: http://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');
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlB ~@ P 1 "� 6 �CEIL Syntax:
CEIL(X)
CEIL() is a synonym for CEILING().
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html:j��@ X� 2 "� 6 �WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS Syntax:
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS(gtid_set[, timeout][,channel])
Wait until the slave SQL thread has executed all of the transactions
whose global transaction identifiers are contained in gtid_set (see
http://dev.mysql.com/doc/refman/5.7/en/replication-gtids-concepts.html,
for a definition of "GTID sets"), or until timeout seconds have
elapsed, whichever occurs first. timeout is optional; the default
timeout is 0 seconds, in which case the function waits until all of the
transactions in the GTID set have been executed.
For more information, see
http://dev.mysql.com/doc/refman/5.7/en/replication-gtids.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html
mysql> SELECT WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS('3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5');
-> 5
http://dev.mysql.com/doc/refman/5.7/en/gtid-functions.html<+8�@ `� 3 "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT LENGTH('text');
-> 4
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html< r�@ h�� 4 "� 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html p �� c��V� �7��"� O N Q !1�E� 9� 6� infimum supremumTM���@ � 5 "� 6 �ST_EQUALS ST_Equals(g1, g2)
Returns 1 or 0 to indicate whether g1 is spatially equal to g2.
URL: http://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 |
+---------------------+---------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-object-shapes.html7
�@ � 6 "� 6 ALTER EVENT (Syntax:
ALTER
[DEFINER = { user | CURRENT_USER }]
EVENT event_name
[ON SCHEDULE schedule]
[ON COMPLETION [NOT] PRESERVE]
[RENAME TO new_event_name]
[ENABLE | DISABLE | DISABLE ON SLAVE]
[COMMENT 'comment']
[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: http://dev.mysql.com/doc/refman/5.7/en/alter-event.html
http://dev.mysql.com/doc/refman/5.7/en/alter-event.htmlC ��@ : 7 "� 6 DATE_SUB Syntax:
DATE_SUB(date,INTERVAL expr unit)
See the description for DATE_ADD().
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html9%��@ (> 8 "� 6 | Syntax:
|
Bitwise OR.
The result is an unsigned 64-bit integer.
URL: http://dev.mysql.com/doc/refman/5.7/en/bit-functions.html
mysql> SELECT 29 | 15;
-> 31
http://dev.mysql.com/doc/refman/5.7/en/bit-functions.htmlK 7�@ 0� 9 "� 6 -ASYMMETRIC_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: http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html= �@ 8� : "� 6 :GEOMFROMTEXT 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.htmlC9i�@ @C ; "� 6 GUUID_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 master and slave 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: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT UUID_SHORT();
-> 92395783831158784
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.htmlC��<�@ Hp < "� 6 TDATEDIFF 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html: �@ P� = "� 6 aDROP PROCEDURE (Syntax:
DROP {PROCEDURE | FUNCTION} [IF EXISTS] sp_name
This statement is used to drop a stored procedure or function. That is,
the specified routine is removed from the server. You must have the
ALTER ROUTINE privilege for the routine. (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
http://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: http://dev.mysql.com/doc/refman/5.7/en/drop-procedure.html
http://dev.mysql.com/doc/refman/5.7/en/drop-procedure.htmlE�S�@ X > "� 6 nST_LATFROMGEOHASH ST_LatFromGeoHash(geohash_str)
Returns the latitude from a geohash string value, as a DOUBLE value in
the range [−90, 90]. The result is NULL if any argument is NULL. An
error occurs if the argument is invalid.
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: http://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 |
+------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-geohash-functions.htmlEG�ŀ@ `� ? "� 6 {ST_GEOMFROMGEOJSON ST_GeomFromGeoJSON(str [, options [, srid]])
Parses a string str representing a GeoJSON object and returns a
geometry.
URL: http://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) |
+--------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/spatial-geojson-functions.html: �@ h
� @ "� 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.
plugin_name is the name of the plugin as defined in the plugin
descriptor structure contained in the library file (see
http://dev.mysql.com/doc/refman/5.7/en/plugin-data-structures.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
table. At server startup, the server loads and initializes any plugin
that is listed in the mysql.plugin table. This means that a plugin is
installed with INSTALL PLUGIN only once, not every time the server
starts. Plugin loading at startup does not occur if the server is
started with the --skip-grant-tables option.
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: http://dev.mysql.com/doc/refman/5.7/en/install-plugin.html
http://dev.mysql.com/doc/refman/5.7/en/install-plugin.html: ��@ pT A "� 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 http://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: http://dev.mysql.com/doc/refman/5.7/en/declare-cursor.html
http://dev.mysql.com/doc/refman/5.7/en/declare-cursor.html5 �@ x � B "� 6 �LOAD DATA P & #http://dev.mysql.com/doc/refman/5.7/en/load-data.htmlC ��@ �B C "� 6 �LOCALTIME Syntax:
LOCALTIME, LOCALTIME([fsp])
LOCALTIME and LOCALTIME() are synonyms for NOW().
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html= �@ �� D "� 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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html@Qr�@ �` E "� 6 �SHA1 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. You
can also use SHA1() as a cryptographic function for storing passwords.
SHA() is synonymous with SHA1().
The return value is a nonbinary string in the connection character set.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SELECT SHA1('abc');
-> 'a9993e364706816aba3e25717850c26c9cd0d89d'
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html@ ��@ �ɝ F "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html p � c��"� !1�&8 P ��
#����Syntax:
LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name'
[REPLACE | IGNORE]
INTO TABLE tbl_name
[PARTITION (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,...)]
[SET col_name = expr,...]
The LOAD DATA INFILE statement reads rows from a text file into a table
at a very high speed. LOAD DATA INFILE is the complement of SELECT ...
INTO OUTFILE. (See
http://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 INFILE. The syntax of the FIELDS and
LINES clauses is the same for both statements. Both clauses are
optional, but FIELDS must precede LINES if both are specified.
You can also load data files by using the mysqlimport utility; it
operates by sending a LOAD DATA INFILE statement to the server. The
--local option causes mysqlimport to read data files from the client
host. You can specify the --compress option to get better performance
over slow networks if the client and server support the compressed
protocol. See http://dev.mysql.com/doc/refman/5.7/en/mysqlimport.html.
For more information about the efficiency of INSERT versus LOAD DATA
INFILE and speeding up LOAD DATA INFILE, see
http://dev.mysql.com/doc/refman/5.7/en/insert-optimization.html.
The file name must be given as a literal string. On Windows, specify
backslashes in path names as forward slashes or doubled backslashes.
The character_set_filesystem system variable controls the
interpretation of the file name.
LOAD DATA supports explicit partition selection using the PARTITION
option with a comma-separated list of one or more names of partitions,
subpartitions, or both. When this option is used, if any rows from the
file cannot be inserted into any of the partitions or subpartitions
named in the list, the statement fails with the error Found a row not
matching the given partition set. For more information, see
http://dev.mysql.com/doc/refman/5.7/en/partitioning-selection.html.
For partitioned tables using storage engines that employ table locks,
such as MyISAM, LOAD DATA cannot prune any partition locks. This does
not apply to tables using storage engines which employ row-level
locking, such as InnoDB. For more information, see
http://dev.mysql.com/doc/refman/5.7/en/partitioning-limitations-locking
.html.
The server uses the character set indicated by the
character_set_database system variable to interpret the information in
the file. SET NAMES and the setting of character_set_client do not
affect interpretation of input. If the contents of the input file use a
character set that differs from the default, it is usually preferable
to specify the character set of the file by using the CHARACTER SET
clause. A character set of binary specifies "no conversion."
LOAD DATA INFILE interprets all fields in the file as having the same
character set, regardless of the data types of the columns into which
field values are loaded. For proper interpretation of file contents,
you must ensure that it was written with the correct character set. For
example, if you write a data file with mysqldump -T or by issuing a
SELECT ... INTO OUTFILE statement in mysql, be sure to use a
--default-character-set option so that output is written in the
character set to be used when the file is loaded with LOAD DATA INFILE.
*Note*:
It is not possible to load data files that use the ucs2, utf16,
utf16le, or utf32 character set.
If you use LOW_PRIORITY, execution of the LOAD DATA statement 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).
If you specify CONCURRENT with a MyISAM table that satisfies the
condition for concurrent inserts (that is, it contains no free blocks
in the middle), other threads can retrieve data from the table while
LOAD DATA is executing. This option affects the performance of LOAD
DATA a bit, even if no other thread is using the table at the same
time.
With row-based replication, CONCURRENT is replicated regardless of
MySQL version. With statement-based replication CONCURRENT is not
replicated prior to MySQL 5.5.1 (see Bug #34628). For more information,
see
http://dev.mysql.com/doc/refman/5.7/en/replication-features-load-data.h
tml.
The LOCAL keyword affects expected location of the file and error
handling, as described later. LOCAL works only if your server and your
client both have been configured to permit it. For example, if mysqld
was started with --local-infile=0, LOCAL does not work. See
http://dev.mysql.com/doc/refman/5.7/en/load-data-local.html.
The LOCAL keyword affects where the file is expected to be found:
o If LOCAL is specified, the file is read by the client program on the
client host and sent to the server. The file can be given as a full
path name to specify its exact location. If given as a relative path
name, the name is interpreted relative to the directory in which the
client program was started.
When using LOCAL with LOAD DATA, a copy of the file is created in the
server's temporary directory. This is not the directory determined by
the value of tmpdir or slave_load_tmpdir, but rather the operating
system's temporary directory, and is not configurable in the MySQL
Server. (Typically the system temporary directory is /tmp on Linux
systems and C:\WINDOWS\TEMP on Windows.) Lack of sufficient space for
the copy in this directory can cause the LOAD DATA LOCAL statement to
fail.
o If LOCAL is not specified, the file must be located on the server
host and is read directly by the server. The server uses the
following rules to locate the file:
o If the file name is an absolute path name, the server uses it as
given.
o If the file name is a relative path name with one or more leading
components, the server searches for the file relative to the
server's data directory.
o If a file name with no leading components is given, the server
looks for the file in the database directory of the default
database.
In the non-LOCAL case, these rules mean that a file named as
./myfile.txt is read from the server's data directory, whereas the file
named as myfile.txt is read from the database directory of the default
database. For example, if db1 is the default database, the following
LOAD DATA statement reads the file data.txt from the database directory
for db1, even though the statement explicitly loads the file into a
table in the db2 database:
LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;
For security reasons, when reading text files located on the server,
the files must either reside in the database directory or be readable
by the user account used to run the server. Also, to use LOAD DATA
INFILE on server files, you must have the FILE privilege. See
http://dev.mysql.com/doc/refman/5.7/en/privileges-provided.html. For
non-LOCAL load operations, 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.
Using LOCAL is a bit slower than letting the server access the files
directly, because the contents of the file must be sent over the
connection by the client to the server. On the other hand, you do not
need the FILE privilege to load local files.
LOCAL also affects error handling:
o With LOAD DATA INFILE, data-interpretation and duplicate-key errors
terminate the operation.
o With LOAD DATA LOCAL INFILE, data-interpretation and duplicate-key
errors become warnings and the operation continues because the server
has no way to stop transmission of the file in the middle of the
operation. For duplicate-key errors, this is the same as if IGNORE is
specified. IGNORE is explained further later in this section.
The REPLACE and IGNORE keywords control handling of input rows that
duplicate existing rows on unique key values:
o If you specify REPLACE, input rows replace existing rows. In other
words, rows that have the same value for a primary key or unique
index as an existing row. See [HELP REPLACE].
o If you specify IGNORE, rows that duplicate an existing row on a
unique key value are discarded. For more information, see
http://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#ignore-strict-co
mparison.
o If you do not specify either option, the behavior depends on whether
the LOCAL keyword is specified. Without LOCAL, an error occurs when a
duplicate key value is found, and the rest of the text file is
ignored. With LOCAL, the default behavior is the same as if IGNORE is
specified; this is because the server has no way to stop transmission
of the file in the middle of the operation.
URL: http://dev.mysql.com/doc/refman/5.7/en/load-data.html
&8 ��=E�� Q O R !��E� ;e� 9@
infimum supremum@���@ � G "� 6 �PASSWORD Syntax:
PASSWORD(str)
*Note*:
This function is deprecated as of MySQL 5.7.6 and will be removed in a
future MySQL release.
Returns a hashed password string calculated from the cleartext password
str. The return value is a nonbinary 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: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> SET old_passwords = 0;
mysql> SELECT PASSWORD('mypass'), OLD_PASSWORD('mypass');
+-------------------------------------------+------------------------+
| PASSWORD('mypass') | OLD_PASSWORD('mypass') |
+-------------------------------------------+------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | 6f8c114b58f2ce9e |
+-------------------------------------------+------------------------+
mysql> SET old_passwords = 1;
mysql> SELECT PASSWORD('mypass'), OLD_PASSWORD('mypass');
+--------------------+------------------------+
| PASSWORD('mypass') | OLD_PASSWORD('mypass') |
+--------------------+------------------------+
| 6f8c114b58f2ce9e | 6f8c114b58f2ce9e |
+--------------------+------------------------+
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.htmlCL��@ � 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 a string or
numeric context.
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
-> '2003-08-14', 20030814
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlJ ʀ@ q I "� 6 �DIMENSION %Dimension(g)
ST_Dimension() and Dimension() are synonyms. For more information, see
the description of ST_Dimension().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.htmlA ��@ (] J "� 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: http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/numeric-type-overview.html9 ؏@ 0n K "� 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 not supported.
For XA END the SUSPEND [FOR MIGRATE] clause is not supported.
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.
For 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/xa-statements.html
http://dev.mysql.com/doc/refman/5.7/en/xa-statements.htmlJ À@ 8j L "� 6 $EQUALS Equals(g1, g2)
MBREquals() and Equals() are synonyms. For more information, see the
description of MBREquals().
URL: http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.html
http://dev.mysql.com/doc/refman/5.7/en/spatial-relation-functions-mbr.htmlJ ʀ@ @q M "� 6 1CENTROID Centroid(mpoly)
ST_Centroid() and Centroid() are synonyms. For more information, see
the description of ST_Centroid().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html< ��@ H" N "� 6 >OCTET_LENGTH &Syntax:
OCTET_LENGTH(str)
OCTET_LENGTH() is a synonym for LENGTH().
URL: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlClā@ P� O "� 6 KUTC_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 a 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html@���@ X> P "� 6 XAES_ENCRYPT Syntax:
AES_ENCRYPT(str,key_str[,init_vector])
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. As of MySQL 5.7.4, 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 cleartext string. If either function argument
is NULL, the function returns NULL.
The str and crypt_str arguments can be any length, and 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. The length of crypt_str can be
calculated using this formula:
16 * (trunc(string_length / 16) + 1)
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))));
Do not pass a password or passphrase directly to crypt_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.
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.4, AES_ENCRYPT() and AES_DECRYPT() permit control of
the block encryption mode and take an optional init_vector
initialization vector argument:
o 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
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
o The optional init_vector argument provides an initialization vector
for block encryption modes that require it.
For modes that require the optional init_vector argument, 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 init_vector, it is ignored and a warning
is generated if it is specified.
A random string of bytes to use for the initialization vector can be
produced by calling RANDOM_BYTES(16). For encryption modes that require
an initialization vector, the same vector must be used for encryption
and decryption.
URL: http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html
mysql> 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 |
+-----------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/encryption-functions.html@ ]@ ` Q "� 6 e+ Syntax:
+
Addition:
URL: http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html
mysql> SELECT 3+5;
-> 8
http://dev.mysql.com/doc/refman/5.7/en/arithmetic-functions.html:d�@ h� R "� 6 rGTID_SUBTRACT Syntax:
GTID_SUBTRACT(set,subset)
Given two sets of global transaction IDs subset and set, returns only
those GTIDs from set that are not in subset.
URL: http://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)
http://dev.mysql.com/doc/refman/5.7/en/gtid-functions.htmlC:U�@ p�0 S "� 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 nonbinary string
in the connection character set. INET_NTOA() returns NULL if it does
not understand its argument.
URL: http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
mysql> SELECT INET_NTOA(167773449);
-> '10.0.5.9'
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html p !
{ c=E�� !��= R Q T !�E� 3�� 2
infimum supremumC4�@ � T "� 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: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYOFWEEK('2007-02-03');
-> 7
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlBV��@ � U "� 6 �CEILING Syntax:
CEILING(X)
Returns the smallest integer value not less than X.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT CEILING(1.23);
-> 2
mysql> SELECT CEILING(-1.23);
-> -1
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html< 5�@ � V "� 6 �SHOW PROCESSLIST Syntax:
SHOW [FULL] PROCESSLIST
SHOW PROCESSLIST shows you which threads are running. You can also get
this information from the INFORMATION_SCHEMA PROCESSLIST table or the
mysqladmin processlist command. If you have the PROCESS privilege, you
can see all threads. Otherwise, you can see only your own threads (that
is, threads associated with the MySQL account that you are using). If
you do not use the FULL keyword, only the first 100 characters of each
statement are shown in the Info field.
URL: http://dev.mysql.com/doc/refman/5.7/en/show-processlist.html
http://dev.mysql.com/doc/refman/5.7/en/show-processlist.html= �@ (� W "� 6 �LINEFROMWKB !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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.htmlJ ր@ 0} X "� 6 �GEOMETRYTYPE %GeometryType(g)
ST_GeometryType() and GeometryType() are synonyms. For more
information, see the description of ST_GeometryType().
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-general-property-functions.html7 �@ 8 � Y "� 6 �CREATE VIEW ( S & 2�http://dev.mysql.com/doc/refman/5.7/en/create-view.html<��o�@ @ Z "� 6 �TRIM &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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlCb�>�@ HA [ "� 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
nonbinary 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: http://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'
http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html2�y�@ P \ "� 6 �SIGNAL 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 special 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
http://dev.mysql.com/doc/refman/5.7/en/diagnostics-area.html.
The condition_value in a SIGNAL statement indicates the error value to
be returned. It can be an SQLSTATE value (a 5-character string literal)
or a condition_name that refers to a named condition previously defined
with DECLARE ... CONDITION (see [HELP DECLARE CONDITION]).
An SQLSTATE value can indicate errors, warnings, or "not found." The
first two characters of the value indicate its error class, as
discussed in
http://dev.mysql.com/doc/refman/5.7/en/signal.html#signal-condition-inf
ormation-items. Some signal values cause statement termination; see
http://dev.mysql.com/doc/refman/5.7/en/signal.html#signal-effects.
The SQLSTATE value for a SIGNAL statement should not start with '00'
because such values indicate success and are not valid for signaling an
error. This is true whether the SQLSTATE value is specified directly in
the SIGNAL statement or in a named condition referred to in the
statement. If the value is invalid, a Bad SQLSTATE error occurs.
To signal a generic SQLSTATE value, use '45000', which means "unhandled
user-defined exception."
The SIGNAL statement optionally includes a SET clause that contains
multiple signal items, in a comma-separated list of
condition_information_item_name = simple_value_specification
assignments.
Each condition_information_item_name may be specified only once in the
SET clause. Otherwise, a Duplicate condition information item error
occurs.
Valid simple_value_specification designators can be specified using
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.
For information about permissible condition_information_item_name
values, see
http://dev.mysql.com/doc/refman/5.7/en/signal.html#signal-condition-inf
ormation-items.
URL: http://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;
http://dev.mysql.com/doc/refman/5.7/en/signal.html5 %�@ X� ] "� 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: http://dev.mysql.com/doc/refman/5.7/en/savepoint.html
http://dev.mysql.com/doc/refman/5.7/en/savepoint.htmlUU���@ `� ^ "� 6!ST_NUMGEOMETRIES ST_NumGeometries(gc)
Returns the number of geometries in the GeometryCollection value gc.
URL: http://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 |
+----------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-geometrycollection-property-functions.htmlD���@ h _ "� 6!JSON_DEPTH 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: http://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 |
+-------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html< �@ p� ` "� 6!(LABELS 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: http://dev.mysql.com/doc/refman/5.7/en/statement-labels.html
http://dev.mysql.com/doc/refman/5.7/en/statement-labels.html= %�@ x�o a "� 6!5MPOINTFROMWKB !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: http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkb-functions.html p
u� c��= !��I� S !q�
2����Syntax:
CREATE
[OR REPLACE]
[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
[DEFINER = { user | CURRENT_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 is the same as ALTER VIEW.
For information about restrictions on view use, see
http://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
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 will 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. CREATE VIEW might also
require the SUPER privilege, depending on the DEFINER value, as
described later in this section.
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 Before MySQL 5.7.7, the SELECT statement cannot contain a subquery in
the FROM clause.
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 a user value is given for the DEFINER clause, it should be a MySQL
account specified as 'user_name'@'host_name', CURRENT_USER, or
CURRENT_USER(). The default DEFINER value is the user who executes the
CREATE VIEW statement. This is the same as specifying DEFINER =
CURRENT_USER explicitly.
If the DEFINER clause is present, these rules determine the valid
DEFINER user values:
o If you do not have the SUPER privilege, the only valid user value is
your own account, either specified literally or by using
CURRENT_USER. You cannot set the definer to some other account.
o If you have the SUPER privilege, you can specify any syntactically
valid account name. If the account does not exist, a warning is
generated.
o Although it is possible to create a view with a nonexistent DEFINER
account, an error occurs when the view is referenced if the SQL
SECURITY value is DEFINER but the definer account does not exist.
For more information about view security, see
http://dev.mysql.com/doc/refman/5.7/en/stored-programs-security.html.
Within a view definition, CURRENT_USER 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
http://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
http://dev.mysql.com/doc/refman/5.7/en/view-algorithms.html, as well as
http://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
http://dev.mysql.com/doc/refman/5.7/en/create-table-generated-columns.h
tml.
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
http://dev.mysql.com/doc/refman/5.7/en/view-updatability.html, and
http://dev.mysql.com/doc/refman/5.7/en/view-check-option.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/create-view.html
��I� !q���� T R U "�E� /�� +g infimum supremum7 ��@ B b "� 6!BALTER TABLE (Syntax:
ALTER TABLE tbl_name
[alter_specification [, alter_specification] ...]
[partition_options]
alter_specification:
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] (index_col_name,...) [index_option] ...
| ADD [CONSTRAINT [symbol]] PRIMARY KEY
[index_type] (index_col_name,...) [index_option] ...
| ADD [CONSTRAINT [symbol]]
UNIQUE [INDEX|KEY] [index_name]
[index_type] (index_col_name,...) [index_option] ...
| ADD FULLTEXT [INDEX|KEY] [index_name]
(index_col_name,...) [index_option] ...
| ADD SPATIAL [INDEX|KEY] [index_name]
(index_col_name,...) [index_option] ...
| ADD [CONSTRAINT [symbol]]
FOREIGN KEY [index_name] (index_col_name,...)
reference_definition
| ALGORITHM [=] {DEFAULT|INPLACE|COPY}
| ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}
| CHANGE [COLUMN] old_col_name new_col_name column_definition
[FIRST|AFTER col_name]
| LOCK [=] {DEFAULT|NONE|SHARED|EXCLUSIVE}
| MODIFY [COLUMN] col_name column_definition
[FIRST | AFTER col_name]
| DROP [COLUMN] col_name
| DROP PRIMARY KEY
| DROP {INDEX|KEY} index_name
| DROP FOREIGN KEY fk_symbol
| DISABLE KEYS
| ENABLE KEYS
| RENAME [TO|AS] new_tbl_name
| RENAME {INDEX|KEY} old_index_name TO new_index_name
| ORDER BY col_name [, col_name] ...
| CONVERT TO CHARACTER SET charset_name [COLLATE collation_name]
| [DEFAULT] CHARACTER SET [=] charset_name [COLLATE [=] collation_name]
| DISCARD TABLESPACE
| IMPORT TABLESPACE
| FORCE
| {WITHOUT|WITH} VALIDATION
| 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
index_col_name:
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] ... (see CREATE TABLE options)
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. See [HELP
CREATE TABLE], for more information.
o The word COLUMN is optional and can be omitted.
o You can issue multiple ADD, ALTER, DROP, and CHANGE clauses 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 Some operations may result in warnings if attempted on a table for
which the storage engine does not support the operation. These
warnings can be displayed with SHOW WARNINGS. See [HELP SHOW
WARNINGS]. For information on troubleshooting ALTER TABLE, see
http://dev.mysql.com/doc/refman/5.7/en/alter-table-problems.html.
o For usage examples, see
http://dev.mysql.com/doc/refman/5.7/en/alter-table-examples.html.
o For information about generated columns, see
http://dev.mysql.com/doc/refman/5.7/en/alter-table-generated-columns.
html.
o With the mysql_info() C API function, you can find out how many rows
were copied by ALTER TABLE. See
http://dev.mysql.com/doc/refman/5.7/en/mysql-info.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/alter-table.html
http://dev.mysql.com/doc/refman/5.7/en/alter-table.html@ ��@ D c "� 6!OCHAR BYTE The CHAR BYTE data type is an alias for the BINARY data type. This is a
compatibility feature.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html= Z�@ � d "� 6!\ST_MLINEFROMTEXT ST_MLineFromText(wkt[, srid]), ST_MultiLineStringFromText(wkt[, srid])
Constructs a MultiLineString value using its WKT representation and
SRID.
The result is NULL if the geometry argument is NULL or not a
syntactically well-formed geometry, or if the SRID argument is NULL.
URL: http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html
http://dev.mysql.com/doc/refman/5.7/en/gis-wkt-functions.html@"a@ ( e "� 6!i> Syntax:
>
Greater than:
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT 2 > 2;
-> 0
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html9 ��@ 0P f "� 6!vANALYZE TABLE Syntax:
ANALYZE [NO_WRITE_TO_BINLOG | LOCAL] TABLE
tbl_name [, tbl_name] ...
ANALYZE TABLE analyzes and stores the key distribution for a table.
During the analysis, the table is locked with a read lock for InnoDB
and MyISAM. This statement works with InnoDB, NDB, and MyISAM tables.
For MyISAM tables, this statement is equivalent to using myisamchk
--analyze. This statement does not work with views.
For more information on how the analysis works within InnoDB, see
http://dev.mysql.com/doc/refman/5.7/en/innodb-persistent-stats.html and
http://dev.mysql.com/doc/refman/5.7/en/innodb-analyze-table-complexity.
html. Also see
http://dev.mysql.com/doc/refman/5.7/en/innodb-restrictions.html. In
particular, when you enable the innodb_stats_persistent option, you
must run ANALYZE TABLE after loading substantial data into an InnoDB
table, or creating a new index for one.
MySQL uses the stored key distribution to decide the order in which
tables should be joined when you perform a join on something other than
a constant. In addition, key distributions can be used when deciding
which indexes to use for a specific table within a query.
This statement requires SELECT and INSERT privileges for the table.
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
http://dev.mysql.com/doc/refman/5.7/en/partitioning-maintenance.html.
In MySQL 5.7.1, gtid_next must be set to AUTOMATIC before issuing this
statement. This restriction does not apply in MySQL 5.7.2 or later.
(Bug #16062608, Bug #16715809, Bug #69045)
URL: http://dev.mysql.com/doc/refman/5.7/en/analyze-table.html
http://dev.mysql.com/doc/refman/5.7/en/analyze-table.htmlJ����@ 8� g "� 6!�ST_EXTERIORRING ST_ExteriorRing(poly)
Returns the exterior ring of the Polygon value poly as a LineString.
URL: http://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) |
+----------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-polygon-property-functions.html<���@ @A h "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
-> 2
mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
-> 0
http://dev.mysql.com/doc/refman/5.7/en/string-functions.htmlE��s�@ H� i "� 6!�CONSTRAINT (MySQL supports foreign keys, which let you cross-reference related data
across tables, and foreign key constraints, which help keep this
spread-out data consistent. The essential syntax for a foreign key
constraint definition in a CREATE TABLE or ALTER TABLE statement looks
like this:
[CONSTRAINT [symbol]] FOREIGN KEY
[index_name] (index_col_name, ...)
REFERENCES tbl_name (index_col_name,...)
[ON DELETE reference_option]
[ON UPDATE reference_option]
reference_option:
RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT
URL: http://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;
http://dev.mysql.com/doc/refman/5.7/en/create-table-foreign-keys.htmlKi��@ P� j "� 6!�CREATE_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
http://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: http://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);
http://dev.mysql.com/doc/refman/5.7/en/enterprise-encryption-functions.html p� c��� "��9p U T V "�E� :`� 3�
infimum supremum< ��@
� k "� 6!�ALTER TABLESPACE (Syntax:
ALTER TABLESPACE tablespace_name
{ADD|DROP} DATAFILE 'file_name'
[INITIAL_SIZE [=] size]
[WAIT]
ENGINE [=] engine_name
This statement can be 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 MySQL 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 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
http://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 http://dev.mysql.com/doc/refman/5.7/en/files-table.html.
ALTER TABLESPACE is useful only with Disk Data storage for MySQL
Cluster. See
http://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-disk-data.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/alter-tablespace.html
http://dev.mysql.com/doc/refman/5.7/en/alter-tablespace.html@ ��@ O l "� 6!�ENUM 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
http://dev.mysql.com/doc/refman/5.7/en/limits-frm-file.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.htmlM7�I�@ + m "� 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. The length of a MultiLineString value is equal to the sum of
the lengths of its elements.
URL: http://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 |
+----------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/gis-linestring-property-functions.htmlG���@ (F n "� 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: http://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
http://dev.mysql.com/doc/refman/5.7/en/string-comparison-functions.html: N�@ 0� o "� 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.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: http://dev.mysql.com/doc/refman/5.7/en/insert-delayed.html
http://dev.mysql.com/doc/refman/5.7/en/insert-delayed.html?����@ 8
p "� 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: http://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.00 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)
http://dev.mysql.com/doc/refman/5.7/en/show-procedure-code.html@ ��@ @0 q "� 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: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html
http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html: O�@ H� r "� 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
http://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: http://dev.mysql.com/doc/refman/5.7/en/show-collation.html
http://dev.mysql.com/doc/refman/5.7/en/show-collation.htmlBY��@ P� s "� 6" LOG 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 (as of MySQL 5.7.4) a warning "Invalid argument for
logarithm" is reported.
The inverse of this function (when called with a single argument) is
the EXP() function.
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT LOG(2);
-> 0.69314718055995
mysql> SELECT LOG(-2);
-> NULL
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html@��c@ X� t "� 6",!= Syntax:
<>, !=
Not equal:
URL: http://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
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html1ȁ@ `� u "� 6"9WHILE 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: http://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;
http://dev.mysql.com/doc/refman/5.7/en/while.htmlG $�@ h� v "� 6"FJSON_APPEND 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.
URL: http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html
http://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.htmlD3��@ p�� w "� 6"SJSON_LENGTH JSON_LENGTH(json_doc[, path])
Returns the length of 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: http://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 |
+------------------------------------------------+
http://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html p$�� c�9p "�*O�= V U���� "%>E� Ѐ � infimum supremumC;)�@ x "� 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
(http://dev.mysql.com/doc/refman/5.7/en/locale-support.html).
URL: http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
mysql> SELECT DAYNAME('2007-02-03');
-> 'Saturday'
http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.htmlB6Ā@ � y "� 6"mRADIANS Syntax:
RADIANS(X)
Returns the argument X, converted from degrees to radians. (Note that
π radians equals 180 degrees.)
URL: http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html
mysql> SELECT RADIANS(90);
-> 1.5707963267949
http://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.htmlA����@ � z "� 6"zCOLLATION Syntax:
COLLATION(str)
Returns the collation of the string argument.
URL: http://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'
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html@e��@ (� { "� 6"�COALESCE Syntax:
COALESCE(value,...)
Returns the first non-NULL value in the list, or NULL if there are no
non-NULL values.
URL: http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html
mysql> SELECT COALESCE(NULL,1);
-> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
-> NULL
http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.htmlA6z�@ 0�� | "� 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
http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html.
URL: http://dev.mysql.com/doc/refman/5.7/en/information-functions.html
mysql> SELECT VERSION();
-> '5.7.19-standard'
http://dev.mysql.com/doc/refman/5.7/en/information-functions.html p c*O�= "%>