mirror of
https://github.com/HeidiSQL/HeidiSQL.git
synced 2025-08-06 18:24:26 +08:00
1360 lines
59 KiB
INI
1360 lines
59 KiB
INI
[ABS]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the absolute value of X, or NULL if X is NULL
|
|
[ACOS]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the arc cosine of X, that is, the value whose cosine is X
|
|
[ADDDATE]
|
|
declaration=date,INTERVAL expr unit
|
|
category=Date and Time Functions
|
|
description=When invoked with the INTERVAL form of the second argument, ADDDATE() is a\nsynonym for DATE_ADD()
|
|
[ADDTIME]
|
|
declaration=expr1,expr2
|
|
category=Date and Time Functions
|
|
description=ADDTIME() adds expr2 to expr1 and returns the result
|
|
[AES_DECRYPT]
|
|
declaration=crypt_str,key_str[,init_vector]
|
|
category=Encryption Functions
|
|
description=This function decrypts data using the official AES (Advanced Encryption\nStandard) algorithm
|
|
[AES_ENCRYPT]
|
|
declaration=str,key_str[,init_vector]
|
|
category=Encryption Functions
|
|
description=AES_ENCRYPT() and AES_DECRYPT() implement encryption and decryption of data\nusing the official AES (Advanced Encryption Standard) algorithm, previously\nknown as "Rijndael
|
|
[ANY_VALUE]
|
|
declaration=arg
|
|
category=Miscellaneous Functions
|
|
description=This function is useful for GROUP BY queries when the ONLY_FULL_GROUP_BY\nSQL mode is enabled, for cases when MySQL rejects a query that you know is\nvalid for reasons that MySQL cannot determine
|
|
[ASCII]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the numeric value of the leftmost character of the string str
|
|
[ASIN]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the arc sine of X, that is, the value whose sine is X
|
|
[ASYMMETRIC_DECRYPT]
|
|
declaration=algorithm, crypt_str, key_str
|
|
category=Enterprise Encryption Functions
|
|
description=Decrypts an encrypted string using the given algorithm and key string, and\nreturns the resulting plaintext as a binary string
|
|
[ASYMMETRIC_DERIVE]
|
|
declaration=pub_key_str, priv_key_str
|
|
category=Enterprise Encryption Functions
|
|
description=Derives a symmetric key using the private key of one party and the public\nkey of another, and returns the resulting key as a binary string
|
|
[ASYMMETRIC_ENCRYPT]
|
|
declaration=algorithm, str, key_str
|
|
category=Enterprise Encryption Functions
|
|
description=Encrypts a string using the given algorithm and key string, and returns the\nresulting ciphertext as a binary string
|
|
[ASYMMETRIC_SIGN]
|
|
declaration=algorithm, digest_str, priv_key_str, digest_type
|
|
category=Enterprise Encryption Functions
|
|
description=Signs a digest string using a private key string, and returns the signature\nas a binary string
|
|
[ASYMMETRIC_VERIFY]
|
|
declaration=algorithm, digest_str, sig_str, pub_key_str,
|
|
digest_type
|
|
category=Enterprise Encryption Functions
|
|
description=Verifies whether the signature string matches the digest string, and\nreturns 1 or 0 to indicate whether verification succeeded or failed
|
|
[ATAN]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the arc tangent of X, that is, the value whose tangent is X
|
|
[AVG]
|
|
declaration=[DISTINCT] expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the average value of expr
|
|
[BENCHMARK]
|
|
declaration=count,expr
|
|
category=Information Functions
|
|
description=The BENCHMARK() function executes the expression expr repeatedly count\ntimes
|
|
[BIN]
|
|
declaration=N
|
|
category=String Functions
|
|
description=Returns a string representation of the binary value of N, where N is a\nlonglong (BIGINT) number
|
|
[BIN_TO_UUID]
|
|
declaration=binary_uuid
|
|
category=Miscellaneous Functions
|
|
description=BIN_TO_UUID() is the inverse of UUID_TO_BIN()
|
|
[BIT_AND]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the bitwise AND of all bits in expr
|
|
[BIT_COUNT]
|
|
declaration=N
|
|
category=Bit Functions
|
|
description=Returns the number of bits that are set in the argument N as an unsigned\n64-bit integer, or NULL if the argument is NULL
|
|
[BIT_LENGTH]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the length of the string str in bits
|
|
[BIT_OR]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the bitwise OR of all bits in expr
|
|
[BIT_XOR]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the bitwise XOR of all bits in expr
|
|
[CAST]
|
|
declaration=expr AS type [ARRAY]
|
|
category=Cast Functions and Operators
|
|
description=The CAST() function takes an expression of any type and produces a result\nvalue of the specified type, similar to CONVERT()
|
|
[CEIL]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=CEIL() is a synonym for CEILING()
|
|
[CEILING]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the smallest integer value not less than X
|
|
[CHARACTER_LENGTH]
|
|
declaration=str
|
|
category=String Functions
|
|
description=CHARACTER_LENGTH() is a synonym for CHAR_LENGTH()
|
|
[CHARSET]
|
|
declaration=str
|
|
category=Information Functions
|
|
description=Returns the character set of the string argument
|
|
[CHAR_LENGTH]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the length of the string str, measured in characters
|
|
[COALESCE]
|
|
declaration=value,...
|
|
category=Comparison Operators
|
|
description=Returns the first non-NULL value in the list, or NULL if there are no\nnon-NULL values
|
|
[COERCIBILITY]
|
|
declaration=str
|
|
category=Information Functions
|
|
description=Returns the collation coercibility value of the string argument
|
|
[COLLATION]
|
|
declaration=str
|
|
category=Information Functions
|
|
description=Returns the collation of the string argument
|
|
[COMPRESS]
|
|
declaration=string_to_compress
|
|
category=Encryption Functions
|
|
description=Compresses a string and returns the result as a binary string
|
|
[CONCAT]
|
|
declaration=str1,str2,...
|
|
category=String Functions
|
|
description=Returns the string that results from concatenating the arguments
|
|
[CONCAT_WS]
|
|
declaration=separator,str1,str2,...
|
|
category=String Functions
|
|
description=CONCAT_WS() stands for Concatenate With Separator and is a special form of\nCONCAT()
|
|
[CONV]
|
|
declaration=N,from_base,to_base
|
|
category=Numeric Functions
|
|
description=Converts numbers between different number bases
|
|
[CONVERT]
|
|
declaration=expr USING transcoding_name
|
|
category=Cast Functions and Operators
|
|
description=The CONVERT() function takes an expression of any type and produces a\nresult value of the specified type
|
|
[CONVERT_TZ]
|
|
declaration=dt,from_tz,to_tz
|
|
category=Date and Time Functions
|
|
description=CONVERT_TZ() converts a datetime value dt from the time zone given by\nfrom_tz to the time zone given by to_tz and returns the resulting value
|
|
[COS]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the cosine of X, where X is given in radians
|
|
[COT]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the cotangent of X
|
|
[COUNT]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns a count of the number of non-NULL values of expr in the rows\nretrieved by a SELECT statement
|
|
[CRC32]
|
|
declaration=expr
|
|
category=Numeric Functions
|
|
description=Computes a cyclic redundancy check value and returns a 32-bit unsigned\nvalue
|
|
[CREATE_ASYMMETRIC_PRIV_KEY]
|
|
declaration=algorithm, {key_len|dh_secret}
|
|
category=Enterprise Encryption Functions
|
|
description=Creates a private key using the given algorithm and key length or DH\nsecret, and returns the key as a binary string in PEM format
|
|
[CREATE_ASYMMETRIC_PUB_KEY]
|
|
declaration=algorithm, priv_key_str
|
|
category=Enterprise Encryption Functions
|
|
description=Derives a public key from the given private key using the given algorithm,\nand returns the key as a binary string in PEM format
|
|
[CREATE_DH_PARAMETERS]
|
|
declaration=key_len
|
|
category=Enterprise Encryption Functions
|
|
description=Creates a shared secret for generating a DH private/public key pair and\nreturns a binary string that can be passed to create_asymmetric_priv_key()
|
|
[CREATE_DIGEST]
|
|
declaration=digest_type, str
|
|
category=Enterprise Encryption Functions
|
|
description=Creates a digest from the given string using the given digest type, and\nreturns the digest as a binary string
|
|
[CURRENT_TIMESTAMP]
|
|
name=CURRENT_TIMESTAMP
|
|
declaration=
|
|
category=Date and Time Functions
|
|
description=CURRENT_TIMESTAMP and CURRENT_TIMESTAMP() are synonyms for NOW().
|
|
[CURTIME]
|
|
declaration=[fsp]
|
|
category=Date and Time Functions
|
|
description=Returns the current time as a value in 'hh:mm:ss' or hhmmss format,\ndepending on whether the function is used in string or numeric context
|
|
[DATEDIFF]
|
|
declaration=expr1,expr2
|
|
category=Date and Time Functions
|
|
description=DATEDIFF() returns expr1 - expr2 expressed as a value in days from one\ndate to the other
|
|
[DATE_ADD]
|
|
declaration=date,INTERVAL expr unit
|
|
category=Date and Time Functions
|
|
description=These functions perform date arithmetic
|
|
[DATE_FORMAT]
|
|
declaration=date,format
|
|
category=Date and Time Functions
|
|
description=Formats the date value according to the format string
|
|
[DATE_SUB]
|
|
declaration=date,INTERVAL expr unit
|
|
category=Date and Time Functions
|
|
description=See the description for DATE_ADD()
|
|
[DAY]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=DAY() is a synonym for DAYOFMONTH()
|
|
[DAYNAME]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the name of the weekday for date
|
|
[DAYOFMONTH]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the day of the month for date, in the range 1 to 31, or 0 for dates\nsuch as '0000-00-00' or '2008-00-00' that have a zero day part
|
|
[DAYOFWEEK]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the weekday index for date (1 = Sunday, 2 = Monday,
|
|
[DAYOFYEAR]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the day of the year for date, in the range 1 to 366
|
|
[DEFAULT]
|
|
declaration=col_name
|
|
category=Miscellaneous Functions
|
|
description=Returns the default value for a table column
|
|
[DEGREES]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the argument X, converted from radians to degrees
|
|
[ELT]
|
|
declaration=N,str1,str2,str3,...
|
|
category=String Functions
|
|
description=ELT() returns the Nth element of the list of strings: str1 if N = 1, str2\nif N = 2, and so on
|
|
[ENUM]
|
|
declaration='value1','value2',...
|
|
category=Data Types
|
|
description=collation_name] An enumeration
|
|
[EXP]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the value of e (the base of natural logarithms) raised to the power\nof X
|
|
[EXPORT_SET]
|
|
declaration=bits,on,off[,separator[,number_of_bits]]
|
|
category=String Functions
|
|
description=Returns a string such that for every bit set in the value bits, you get an\non string and for every bit not set in the value, you get an off string
|
|
[EXTRACT]
|
|
declaration=unit FROM date
|
|
category=Date and Time Functions
|
|
description=The EXTRACT() function uses the same kinds of unit specifiers as DATE_ADD()\nor DATE_SUB(), but extracts parts from the date rather than performing date\narithmetic
|
|
[EXTRACTVALUE]
|
|
declaration=xml_frag, xpath_expr
|
|
category=XML
|
|
description=ExtractValue() takes two string arguments, a fragment of XML markup\nxml_frag and an XPath expression xpath_expr (also known as a locator); it\nreturns the text (CDATA) of the first text node which is a child of the\nelement or elements matched by the XPath expression
|
|
[FIELD]
|
|
declaration=str,str1,str2,str3,...
|
|
category=String Functions
|
|
description=Returns the index (position) of str in the str1, str2, str3,
|
|
[FIND_IN_SET]
|
|
declaration=str,strlist
|
|
category=String Functions
|
|
description=Returns a value in the range of 1 to N if the string str is in the string\nlist strlist consisting of N substrings
|
|
[FIRST_VALUE]
|
|
declaration=expr
|
|
category=Window Functions
|
|
description=Returns the value of expr from the first row of the window frame
|
|
[FLOOR]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the largest integer value not greater than X
|
|
[FORMAT]
|
|
declaration=X,D[,locale]
|
|
category=String Functions
|
|
description=Formats the number X to a format like '#,###,###
|
|
[FORMAT_BYTES]
|
|
declaration=count
|
|
category=Performance Schema Functions
|
|
description=Given a numeric byte count, converts it to human-readable format and\nreturns a string consisting of a value and a units indicator
|
|
[FORMAT_PICO_TIME]
|
|
declaration=time_val
|
|
category=Performance Schema Functions
|
|
description=Given a numeric Performance Schema latency or wait time in picoseconds,\nconverts it to human-readable format and returns a string consisting of a\nvalue and a units indicator
|
|
[FROM_BASE64]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Takes a string encoded with the base-64 encoded rules used by TO_BASE64()\nand returns the decoded result as a binary string
|
|
[FROM_DAYS]
|
|
declaration=N
|
|
category=Date and Time Functions
|
|
description=Given a day number N, returns a DATE value
|
|
[FROM_UNIXTIME]
|
|
declaration=unix_timestamp[,format]
|
|
category=Date and Time Functions
|
|
description=Returns a representation of the unix_timestamp argument as a value in\n'YYYY-MM-DD hh:mm:ss' or YYYYMMDDhhmmss format, depending on whether the\nfunction is used in a string or numeric context
|
|
[GEOMCOLLECTION]
|
|
declaration=g [, g] ...
|
|
category=Geometry Constructors
|
|
description=Constructs a GeomCollection value from the geometry arguments
|
|
[GEOMETRYCOLLECTION]
|
|
declaration=g [, g] ...
|
|
category=Geometry Constructors
|
|
description=Constructs a GeomCollection value from the geometry arguments
|
|
[GET_FORMAT]
|
|
declaration={DATE|TIME|DATETIME}, {'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL'}
|
|
category=Date and Time Functions
|
|
description=Returns a format string
|
|
[GET_LOCK]
|
|
declaration=str,timeout
|
|
category=Locking Functions
|
|
description=Tries to obtain a lock with a name given by the string str, using a timeout\nof timeout seconds
|
|
[GREATEST]
|
|
declaration=value1,value2,...
|
|
category=Comparison Operators
|
|
description=With two or more arguments, returns the largest (maximum-valued) argument
|
|
[GROUPING]
|
|
declaration=expr [, expr] ...
|
|
category=Miscellaneous Functions
|
|
description=For GROUP BY queries that include a WITH ROLLUP modifier, the ROLLUP\noperation produces super-aggregate output rows where NULL represents the\nset of all values
|
|
[GROUP_CONCAT]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=This function returns a string result with the concatenated non-NULL values\nfrom a group
|
|
[GTID_SUBSET]
|
|
declaration=set1,set2
|
|
category=GTID
|
|
description=Given two sets of global transaction identifiers set1 and set2, returns\ntrue if all GTIDs in set1 are also in set2
|
|
[GTID_SUBTRACT]
|
|
declaration=set1,set2
|
|
category=GTID
|
|
description=Given two sets of global transaction identifiers set1 and set2, returns\nonly those GTIDs from set1 that are not in set2
|
|
[HEX]
|
|
declaration=str
|
|
category=String Functions
|
|
description=For a string argument str, HEX() returns a hexadecimal string\nrepresentation of str where each byte of each character in str is converted\nto two hexadecimal digits
|
|
[HOUR]
|
|
declaration=time
|
|
category=Date and Time Functions
|
|
description=Returns the hour for time
|
|
[IFNULL]
|
|
declaration=expr1,expr2
|
|
category=Flow Control Functions
|
|
description=If expr1 is not NULL, IFNULL() returns expr1; otherwise it returns expr2
|
|
[INET6_ATON]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=Given an IPv6 or IPv4 network address as a string, returns a binary string\nthat represents the numeric value of the address in network byte order (big\nendian)
|
|
[INET6_NTOA]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=Given an IPv6 or IPv4 network address represented in numeric form as a\nbinary string, returns the string representation of the address as a string\nin the connection character set
|
|
[INET_ATON]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=Given the dotted-quad representation of an IPv4 network address as a\nstring, returns an integer that represents the numeric value of the address\nin network byte order (big endian)
|
|
[INET_NTOA]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=Given a numeric IPv4 network address in network byte order, returns the\ndotted-quad string representation of the address as a string in the\nconnection character set
|
|
[INSTR]
|
|
declaration=str,substr
|
|
category=String Functions
|
|
description=Returns the position of the first occurrence of substring substr in string\nstr
|
|
[INTERVAL]
|
|
declaration=N,N1,N2,N3,...
|
|
category=Comparison Operators
|
|
description=Returns 0 if N < N1, 1 if N < N2 and so on or -1 if N is NULL
|
|
[ISNULL]
|
|
declaration=expr
|
|
category=Comparison Operators
|
|
description=If expr is NULL, ISNULL() returns 1, otherwise it returns 0
|
|
[IS_FREE_LOCK]
|
|
declaration=str
|
|
category=Locking Functions
|
|
description=Checks whether the lock named str is free to use (that is, not locked)
|
|
[IS_IPV4]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=Returns 1 if the argument is a valid IPv4 address specified as a string, 0\notherwise
|
|
[IS_IPV4_COMPAT]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=This function takes an IPv6 address represented in numeric form as a binary\nstring, as returned by INET6_ATON()
|
|
[IS_IPV4_MAPPED]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=This function takes an IPv6 address represented in numeric form as a binary\nstring, as returned by INET6_ATON()
|
|
[IS_IPV6]
|
|
declaration=expr
|
|
category=Miscellaneous Functions
|
|
description=Returns 1 if the argument is a valid IPv6 address specified as a string, 0\notherwise
|
|
[IS_USED_LOCK]
|
|
declaration=str
|
|
category=Locking Functions
|
|
description=Checks whether the lock named str is in use (that is, locked)
|
|
[IS_UUID]
|
|
declaration=string_uuid
|
|
category=Miscellaneous Functions
|
|
description=Returns 1 if the argument is a valid string-format UUID, 0 if the argument\nis not a valid UUID, and NULL if the argument is NULL
|
|
[JSON_ARRAY]
|
|
declaration=[val[, val] ...]
|
|
category=MBR Functions
|
|
description=Evaluates a (possibly empty) list of values and returns a JSON array\ncontaining those values
|
|
[JSON_ARRAYAGG]
|
|
declaration=col_or_expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Aggregates a result set as a single JSON array whose elements consist of\nthe rows
|
|
[JSON_ARRAY_APPEND]
|
|
declaration=json_doc, path, val[, path, val] ...
|
|
category=MBR Functions
|
|
description=Appends values to the end of the indicated arrays within a JSON document\nand returns the result
|
|
[JSON_ARRAY_INSERT]
|
|
declaration=json_doc, path, val[, path, val] ...
|
|
category=MBR Functions
|
|
description=Updates a JSON document, inserting into an array within the document and\nreturning the modified document
|
|
[JSON_CONTAINS]
|
|
declaration=target, candidate[, path]
|
|
category=MBR Functions
|
|
description=Indicates by returning 1 or 0 whether a given candidate JSON document is\ncontained within a target JSON document, or---if a path argument was\nsupplied---whether the candidate is found at a specific path within the\ntarget
|
|
[JSON_CONTAINS_PATH]
|
|
declaration=json_doc, one_or_all, path[, path] ...
|
|
category=MBR Functions
|
|
description=Returns 0 or 1 to indicate whether a JSON document contains data at a given\npath or paths
|
|
[JSON_DEPTH]
|
|
declaration=json_doc
|
|
category=MBR Functions
|
|
description=Returns the maximum depth of a JSON document
|
|
[JSON_EXTRACT]
|
|
declaration=json_doc, path[, path] ...
|
|
category=MBR Functions
|
|
description=Returns data from a JSON document, selected from the parts of the document\nmatched by the path arguments
|
|
[JSON_INSERT]
|
|
declaration=json_doc, path, val[, path, val] ...
|
|
category=MBR Functions
|
|
description=Inserts data into a JSON document and returns the result
|
|
[JSON_KEYS]
|
|
declaration=json_doc[, path]
|
|
category=MBR Functions
|
|
description=Returns the keys from the top-level value of a JSON object as a JSON array,\nor, if a path argument is given, the top-level keys from the selected path
|
|
[JSON_LENGTH]
|
|
declaration=json_doc[, path]
|
|
category=MBR Functions
|
|
description=Returns the length of a JSON document, or, if a path argument is given, the\nlength of the value within the document identified by the path
|
|
[JSON_MERGE]
|
|
declaration=json_doc, json_doc[, json_doc] ...
|
|
category=MBR Functions
|
|
description=Merges two or more JSON documents
|
|
[JSON_OBJECT]
|
|
declaration=[key, val[, key, val] ...]
|
|
category=MBR Functions
|
|
description=Evaluates a (possibly empty) list of key-value pairs and returns a JSON\nobject containing those pairs
|
|
[JSON_OBJECTAGG]
|
|
declaration=key, value
|
|
category=Aggregate Functions and Modifiers
|
|
description=Takes two column names or expressions as arguments, the first of these\nbeing used as a key and the second as a value, and returns a JSON object\ncontaining key-value pairs
|
|
[JSON_OVERLAPS]
|
|
declaration=json_doc1, json_doc2
|
|
category=MBR Functions
|
|
description=Compares two JSON documents
|
|
[JSON_PRETTY]
|
|
declaration=json_val
|
|
category=MBR Functions
|
|
description=Provides pretty-printing of JSON values similar to that implemented in PHP\nand by other languages and database systems
|
|
[JSON_QUOTE]
|
|
declaration=string
|
|
category=MBR Functions
|
|
description=Quotes a string as a JSON value by wrapping it with double quote characters\nand escaping interior quote and other characters, then returning the result\nas a utf8mb4 string
|
|
[JSON_REMOVE]
|
|
declaration=json_doc, path[, path] ...
|
|
category=MBR Functions
|
|
description=Removes data from a JSON document and returns the result
|
|
[JSON_REPLACE]
|
|
declaration=json_doc, path, val[, path, val] ...
|
|
category=MBR Functions
|
|
description=Replaces existing values in a JSON document and returns the result
|
|
[JSON_SCHEMA_VALID]
|
|
declaration=schema,document
|
|
category=MBR Functions
|
|
description=Validates a JSON document against a JSON schema
|
|
[JSON_SCHEMA_VALIDATION_REPORT]
|
|
declaration=schema,document
|
|
category=MBR Functions
|
|
description=Validates a JSON document against a JSON schema
|
|
[JSON_SEARCH]
|
|
declaration=json_doc, one_or_all, search_str[, escape_char[, path] ...]
|
|
category=MBR Functions
|
|
description=Returns the path to the given string within a JSON document
|
|
[JSON_SET]
|
|
declaration=json_doc, path, val[, path, val] ...
|
|
category=MBR Functions
|
|
description=Inserts or updates data in a JSON document and returns the result
|
|
[JSON_STORAGE_FREE]
|
|
declaration=json_val
|
|
category=MBR Functions
|
|
description=For a JSON column value, this function shows how much storage space was\nfreed in its binary representation after it was updated in place using\nJSON_SET(), JSON_REPLACE(), or JSON_REMOVE()
|
|
[JSON_STORAGE_SIZE]
|
|
declaration=json_val
|
|
category=MBR Functions
|
|
description=This function returns the number of bytes used to store the binary\nrepresentation of a JSON document
|
|
[JSON_TABLE]
|
|
declaration=expr, path COLUMNS (column_list
|
|
category=MBR Functions
|
|
description=Extracts data from a JSON document and returns it as a relational table\nhaving the specified columns
|
|
[JSON_TYPE]
|
|
declaration=json_val
|
|
category=MBR Functions
|
|
description=Returns a utf8mb4 string indicating the type of a JSON value
|
|
[JSON_UNQUOTE]
|
|
declaration=json_val
|
|
category=MBR Functions
|
|
description=Unquotes JSON value and returns the result as a utf8mb4 string
|
|
[JSON_VALID]
|
|
declaration=val
|
|
category=MBR Functions
|
|
description=Returns 0 or 1 to indicate whether a value is valid JSON
|
|
[JSON_VALUE]
|
|
declaration=json_doc, path
|
|
category=MBR Functions
|
|
description=Extracts a value from a JSON document at the path given in the specified\ndocument, and returns the extracted value, optionally converting it to a\ndesired type
|
|
[LAG]
|
|
declaration=expr [, N[, default]]
|
|
category=Window Functions
|
|
description=Returns the value of expr from the row that lags (precedes) the current row\nby N rows within its partition
|
|
[LAST_DAY]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Takes a date or datetime value and returns the corresponding value for the\nlast day of the month
|
|
[LAST_VALUE]
|
|
declaration=expr
|
|
category=Window Functions
|
|
description=Returns the value of expr from the last row of the window frame
|
|
[LCASE]
|
|
declaration=str
|
|
category=String Functions
|
|
description=LCASE() is a synonym for LOWER()
|
|
[LEAD]
|
|
declaration=expr [, N[, default]]
|
|
category=Window Functions
|
|
description=Returns the value of expr from the row that leads (follows) the current row\nby N rows within its partition
|
|
[LEAST]
|
|
declaration=value1,value2,...
|
|
category=Comparison Operators
|
|
description=With two or more arguments, returns the smallest (minimum-valued) argument
|
|
[LEFT]
|
|
declaration=str,len
|
|
category=String Functions
|
|
description=Returns the leftmost len characters from the string str, or NULL if any\nargument is NULL
|
|
[LENGTH]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the length of the string str, measured in bytes
|
|
[LINESTRING]
|
|
declaration=pt [, pt] ...
|
|
category=Geometry Constructors
|
|
description=Constructs a LineString value from a number of Point or WKB Point arguments
|
|
[LN]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the natural logarithm of X; that is, the base-e logarithm of X
|
|
[LOAD_FILE]
|
|
declaration=file_name
|
|
category=String Functions
|
|
description=Reads the file and returns the file contents as a string
|
|
[LOCATE]
|
|
declaration=substr,str
|
|
category=String Functions
|
|
description=The first syntax returns the position of the first occurrence of substring\nsubstr in string str
|
|
[LOG]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=If called with one parameter, this function returns the natural logarithm\nof X
|
|
[LOG10]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the base-10 logarithm of X
|
|
[LOG2]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the base-2 logarithm of X
|
|
[LOWER]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the string str with all characters changed to lowercase according\nto the current character set mapping
|
|
[LPAD]
|
|
declaration=str,len,padstr
|
|
category=String Functions
|
|
description=Returns the string str, left-padded with the string padstr to a length of\nlen characters
|
|
[LTRIM]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the string str with leading space characters removed
|
|
[MAKEDATE]
|
|
declaration=year,dayofyear
|
|
category=Date and Time Functions
|
|
description=Returns a date, given year and day-of-year values
|
|
[MAKETIME]
|
|
declaration=hour,minute,second
|
|
category=Date and Time Functions
|
|
description=Returns a time value calculated from the hour, minute, and second arguments
|
|
[MAKE_SET]
|
|
declaration=bits,str1,str2,...
|
|
category=String Functions
|
|
description=Returns a set value (a string containing substrings separated by ,\ncharacters) consisting of the strings that have the corresponding bit in\nbits set
|
|
[MASTER_POS_WAIT]
|
|
declaration=log_name,log_pos[,timeout][,channel]
|
|
category=Miscellaneous Functions
|
|
description=This function is useful for control of source/replica synchronization
|
|
[MAX]
|
|
declaration=[DISTINCT] expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the maximum value of expr
|
|
[MBRCONTAINS]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1\ncontains the minimum bounding rectangle of g2
|
|
[MBRCOVEREDBY]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1 is\ncovered by the minimum bounding rectangle of g2
|
|
[MBRCOVERS]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1\ncovers the minimum bounding rectangle of g2
|
|
[MBRDISJOINT]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Returns 1 or 0 to indicate whether the minimum bounding rectangles of the\ntwo geometries g1 and g2 are disjoint (do not intersect)
|
|
[MBREQUALS]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Returns 1 or 0 to indicate whether the minimum bounding rectangles of the\ntwo geometries g1 and g2 are the same
|
|
[MBRINTERSECTS]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Returns 1 or 0 to indicate whether the minimum bounding rectangles of the\ntwo geometries g1 and g2 intersect
|
|
[MBROVERLAPS]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Two geometries spatially overlap if they intersect and their intersection\nresults in a geometry of the same dimension but not equal to either of the\ngiven geometries
|
|
[MBRTOUCHES]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Two geometries spatially touch if their interiors do not intersect, but the\nboundary of one of the geometries intersects either the boundary or the\ninterior of the other
|
|
[MBRWITHIN]
|
|
declaration=g1, g2
|
|
category=MBR Functions
|
|
description=Returns 1 or 0 to indicate whether the minimum bounding rectangle of g1 is\nwithin the minimum bounding rectangle of g2
|
|
[MD5]
|
|
declaration=str
|
|
category=Encryption Functions
|
|
description=Calculates an MD5 128-bit checksum for the string
|
|
[MICROSECOND]
|
|
declaration=expr
|
|
category=Date and Time Functions
|
|
description=Returns the microseconds from the time or datetime expression expr as a\nnumber in the range from 0 to 999999
|
|
[MID]
|
|
declaration=str,pos,len
|
|
category=String Functions
|
|
description=MID(str,pos,len) is a synonym for SUBSTRING(str,pos,len)
|
|
[MIN]
|
|
declaration=[DISTINCT] expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the minimum value of expr
|
|
[MINUTE]
|
|
declaration=time
|
|
category=Date and Time Functions
|
|
description=Returns the minute for time, in the range 0 to 59
|
|
[MOD]
|
|
declaration=N,M
|
|
category=Numeric Functions
|
|
description=Modulo operation
|
|
[MONTH]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the month for date, in the range 1 to 12 for January to December,\nor 0 for dates such as '0000-00-00' or '2008-00-00' that have a zero month\npart
|
|
[MONTHNAME]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the full name of the month for date
|
|
[MULTILINESTRING]
|
|
declaration=ls [, ls] ...
|
|
category=Geometry Constructors
|
|
description=Constructs a MultiLineString value using LineString or WKB LineString\narguments
|
|
[MULTIPOINT]
|
|
declaration=pt [, pt2] ...
|
|
category=Geometry Constructors
|
|
description=Constructs a MultiPoint value using Point or WKB Point arguments
|
|
[MULTIPOLYGON]
|
|
declaration=poly [, poly] ...
|
|
category=Geometry Constructors
|
|
description=Constructs a MultiPolygon value from a set of Polygon or WKB Polygon\narguments
|
|
[NAME_CONST]
|
|
declaration=name,value
|
|
category=Miscellaneous Functions
|
|
description=Returns the given value
|
|
[NOW]
|
|
declaration=[fsp]
|
|
category=Date and Time Functions
|
|
description=Returns the current date and time as a value in 'YYYY-MM-DD hh:mm:ss' or\nYYYYMMDDhhmmss format, depending on whether the function is used in string\nor numeric context
|
|
[NTH_VALUE]
|
|
declaration=expr, N
|
|
category=Window Functions
|
|
description=Returns the value of expr from the N-th row of the window frame
|
|
[NTILE]
|
|
declaration=N
|
|
category=Window Functions
|
|
description=Divides a partition into N groups (buckets), assigns each row in the\npartition its bucket number, and returns the bucket number of the current\nrow within its partition
|
|
[NULLIF]
|
|
declaration=expr1,expr2
|
|
category=Flow Control Functions
|
|
description=Returns NULL if expr1 = expr2 is true, otherwise returns expr1
|
|
[OCT]
|
|
declaration=N
|
|
category=String Functions
|
|
description=Returns a string representation of the octal value of N, where N is a\nlonglong (BIGINT) number
|
|
[OCTET_LENGTH]
|
|
declaration=str
|
|
category=String Functions
|
|
description=OCTET_LENGTH() is a synonym for LENGTH()
|
|
[ORD]
|
|
declaration=str
|
|
category=String Functions
|
|
description=If the leftmost character of the string str is a multibyte character,\nreturns the code for that character, calculated from the numeric values of\nits constituent bytes using this formula: (1st byte code) + (2nd byte\ncode * 256) + (3rd byte code * 256^2)
|
|
[PERIOD_ADD]
|
|
declaration=P,N
|
|
category=Date and Time Functions
|
|
description=Adds N months to period P (in the format YYMM or YYYYMM)
|
|
[PERIOD_DIFF]
|
|
declaration=P1,P2
|
|
category=Date and Time Functions
|
|
description=Returns the number of months between periods P1 and P2
|
|
[POINT]
|
|
declaration=x, y
|
|
category=Geometry Constructors
|
|
description=Constructs a Point using its coordinates
|
|
[POLYGON]
|
|
declaration=ls [, ls] ...
|
|
category=Geometry Constructors
|
|
description=Constructs a Polygon value from a number of LineString or WKB LineString\narguments
|
|
[POSITION]
|
|
declaration=substr IN str
|
|
category=String Functions
|
|
description=POSITION(substr IN str) is a synonym for LOCATE(substr,str)
|
|
[POW]
|
|
declaration=X,Y
|
|
category=Numeric Functions
|
|
description=Returns the value of X raised to the power of Y
|
|
[POWER]
|
|
declaration=X,Y
|
|
category=Numeric Functions
|
|
description=This is a synonym for POW()
|
|
[PS_THREAD_ID]
|
|
declaration=connection_id
|
|
category=Performance Schema Functions
|
|
description=Given a connection ID, returns a BIGINT UNSIGNED value representing the\nPerformance Schema thread ID assigned to the connection ID, or NULL if no\nthread ID exists for the connection ID
|
|
[QUARTER]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the quarter of the year for date, in the range 1 to 4
|
|
[QUOTE]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Quotes a string to produce a result that can be used as a properly escaped\ndata value in an SQL statement
|
|
[RADIANS]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the argument X, converted from degrees to radians
|
|
[RAND]
|
|
declaration=[N]
|
|
category=Numeric Functions
|
|
description=Returns a random floating-point value v in the range 0 <= v < 1
|
|
[RANDOM_BYTES]
|
|
declaration=len
|
|
category=Encryption Functions
|
|
description=This function returns a binary string of len random bytes generated using\nthe random number generator of the SSL library
|
|
[REGEXP_INSTR]
|
|
declaration=expr, pat[, pos[, occurrence[, return_option[,
|
|
match_type]]]]
|
|
category=String Functions
|
|
description=Returns the starting index of the substring of the string expr that matches\nthe regular expression specified by the pattern pat, 0 if there is no match
|
|
[REGEXP_LIKE]
|
|
declaration=expr, pat[, match_type]
|
|
category=String Functions
|
|
description=Returns 1 if the string expr matches the regular expression specified by\nthe pattern pat, 0 otherwise
|
|
[REGEXP_REPLACE]
|
|
declaration=expr, pat, repl[, pos[, occurrence[, match_type]]]
|
|
category=String Functions
|
|
description=Replaces occurrences in the string expr that match the regular expression\nspecified by the pattern pat with the replacement string repl, and returns\nthe resulting string
|
|
[REGEXP_SUBSTR]
|
|
declaration=expr, pat[, pos[, occurrence[, match_type]]]
|
|
category=String Functions
|
|
description=Returns the substring of the string expr that matches the regular\nexpression specified by the pattern pat, NULL if there is no match
|
|
[RELEASE_LOCK]
|
|
declaration=str
|
|
category=Locking Functions
|
|
description=Releases the lock named by the string str that was obtained with GET_LOCK()
|
|
[REVERSE]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the string str with the order of the characters reversed
|
|
[RIGHT]
|
|
declaration=str,len
|
|
category=String Functions
|
|
description=Returns the rightmost len characters from the string str, or NULL if any\nargument is NULL
|
|
[ROUND]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Rounds the argument X to D decimal places
|
|
[RPAD]
|
|
declaration=str,len,padstr
|
|
category=String Functions
|
|
description=Returns the string str, right-padded with the string padstr to a length of\nlen characters
|
|
[RTRIM]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the string str with trailing space characters removed
|
|
[SECOND]
|
|
declaration=time
|
|
category=Date and Time Functions
|
|
description=Returns the second for time, in the range 0 to 59
|
|
[SEC_TO_TIME]
|
|
declaration=seconds
|
|
category=Date and Time Functions
|
|
description=Returns the seconds argument, converted to hours, minutes, and seconds, as\na TIME value
|
|
[SHA1]
|
|
declaration=str
|
|
category=Encryption Functions
|
|
description=Calculates an SHA-1 160-bit checksum for the string, as described in RFC\n3174 (Secure Hash Algorithm)
|
|
[SHA2]
|
|
declaration=str, hash_length
|
|
category=Encryption Functions
|
|
description=Calculates the SHA-2 family of hash functions (SHA-224, SHA-256, SHA-384,\nand SHA-512)
|
|
[SIGN]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the sign of the argument as -1, 0, or 1, depending on whether X is\nnegative, zero, or positive
|
|
[SIN]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the sine of X, where X is given in radians
|
|
[SLEEP]
|
|
declaration=duration
|
|
category=Miscellaneous Functions
|
|
description=Sleeps (pauses) for the number of seconds given by the duration argument,\nthen returns 0
|
|
[SOUNDEX]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns a soundex string from str
|
|
[SPACE]
|
|
declaration=N
|
|
category=String Functions
|
|
description=Returns a string consisting of N space characters
|
|
[SQRT]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the square root of a nonnegative number X
|
|
[STATEMENT_DIGEST]
|
|
declaration=statement
|
|
category=Encryption Functions
|
|
description=Given an SQL statement as a string, returns the statement digest hash value\nas a string in the connection character set, or NULL if the argument is\nNULL
|
|
[STATEMENT_DIGEST_TEXT]
|
|
declaration=statement
|
|
category=Encryption Functions
|
|
description=Given an SQL statement as a string, returns the normalized statement digest\nas a string in the connection character set, or NULL if the argument is\nNULL
|
|
[STD]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the population standard deviation of expr
|
|
[STDDEV]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the population standard deviation of expr
|
|
[STDDEV_POP]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the population standard deviation of expr (the square root of\nVAR_POP())
|
|
[STDDEV_SAMP]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the sample standard deviation of expr (the square root of\nVAR_SAMP()
|
|
[STRCMP]
|
|
declaration=expr1,expr2
|
|
category=String Functions
|
|
description=STRCMP() returns 0 if the strings are the same, -1 if the first argument is\nsmaller than the second according to the current sort order, and 1\notherwise
|
|
[STR_TO_DATE]
|
|
declaration=str,format
|
|
category=Date and Time Functions
|
|
description=This is the inverse of the DATE_FORMAT() function
|
|
[ST_AREA]
|
|
declaration={poly|mpoly}
|
|
category=Polygon Property Functions
|
|
description=Returns a double-precision number indicating the area of the Polygon or\nMultiPolygon argument, as measured in its spatial reference system
|
|
[ST_ASBINARY]
|
|
declaration=g [, options]
|
|
category=WKB Functions
|
|
description=Converts a value in internal geometry format to its WKB representation and\nreturns the binary result
|
|
[ST_ASGEOJSON]
|
|
declaration=g [, max_dec_digits [, options]]
|
|
category=MBR Functions
|
|
description=Generates a GeoJSON object from the geometry g
|
|
[ST_ASTEXT]
|
|
declaration=g [, options]
|
|
category=WKB Functions
|
|
description=Converts a value in internal geometry format to its WKT representation and\nreturns the string result
|
|
[ST_BUFFER]
|
|
declaration=g, d [, strategy1 [, strategy2 [, strategy3]]]
|
|
category=GeometryCollection Property Functions
|
|
description=Returns a geometry that represents all points whose distance from the\ngeometry value g is less than or equal to a distance of d
|
|
[ST_BUFFER_STRATEGY]
|
|
declaration=strategy [, points_per_circle]
|
|
category=GeometryCollection Property Functions
|
|
description=This function returns a strategy byte string for use with ST_Buffer() to\ninfluence buffer computation
|
|
[ST_CENTROID]
|
|
declaration={poly|mpoly}
|
|
category=Polygon Property Functions
|
|
description=Returns the mathematical centroid for the Polygon or MultiPolygon argument\nas a Point
|
|
[ST_COLLECT]
|
|
declaration=[DISTINCT] g
|
|
category=MBR Functions
|
|
description=Aggregates geometry values and returns a single geometry collection value
|
|
[ST_CONTAINS]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Returns 1 or 0 to indicate whether g1 completely contains g2
|
|
[ST_CONVEXHULL]
|
|
declaration=g
|
|
category=GeometryCollection Property Functions
|
|
description=Returns a geometry that represents the convex hull of the geometry value g
|
|
[ST_CROSSES]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Two geometries spatially cross if their spatial relation has the following\nproperties: o Unless g1 and g2 are both of dimension 1: g1 crosses g2 if\nthe interior of g2 has points in common with the interior of g1, but g2 \ndoes not cover the entire interior of g1
|
|
[ST_DIFFERENCE]
|
|
declaration=g1, g2
|
|
category=GeometryCollection Property Functions
|
|
description=Returns a geometry that represents the point set difference of the geometry\nvalues g1 and g2
|
|
[ST_DIMENSION]
|
|
declaration=g
|
|
category=Geometry Property Functions
|
|
description=Returns the inherent dimension of the geometry value g
|
|
[ST_DISJOINT]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Returns 1 or 0 to indicate whether g1 is spatially disjoint from (does not\nintersect) g2
|
|
[ST_DISTANCE]
|
|
declaration=g1, g2 [, unit]
|
|
category=Geometry Relation Functions
|
|
description=Returns the distance between g1 and g2, measured in the length unit of the\nspatial reference system (SRS) of the geometry arguments, or in the unit of\nthe optional unit argument if that is specified
|
|
[ST_DISTANCE_SPHERE]
|
|
declaration=g1, g2 [, radius]
|
|
category=MBR Functions
|
|
description=Returns the mimimum spherical distance between Point or MultiPoint\narguments on a sphere, in meters
|
|
[ST_ENDPOINT]
|
|
declaration=ls
|
|
category=LineString Property Functions
|
|
description=Returns the Point that is the endpoint of the LineString value ls
|
|
[ST_ENVELOPE]
|
|
declaration=g
|
|
category=Geometry Property Functions
|
|
description=Returns the minimum bounding rectangle (MBR) for the geometry value g
|
|
[ST_EQUALS]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Returns 1 or 0 to indicate whether g1 is spatially equal to g2
|
|
[ST_EXTERIORRING]
|
|
declaration=poly
|
|
category=Polygon Property Functions
|
|
description=Returns the exterior ring of the Polygon value poly as a LineString
|
|
[ST_FRECHETDISTANCE]
|
|
declaration=g1, g2 [, unit]
|
|
category=Geometry Relation Functions
|
|
description=Returns the discrete Fr├®chet distance between two geometries, reflecting\nhow similar the geometries are
|
|
[ST_GEOHASH]
|
|
declaration=longitude, latitude, max_length
|
|
category=MBR Functions
|
|
description=max_length) Returns a geohash string in the connection character set and\ncollation
|
|
[ST_GEOMCOLLFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=ST_GeometryCollectionFromText(wkt [, srid [, options]]),\nST_GeomCollFromTxt(wkt [, srid [, options]]) Constructs a\nGeometryCollection value using its WKT representation and SRID
|
|
[ST_GEOMCOLLFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=ST_GeometryCollectionFromWKB(wkb [, srid [, options]]) Constructs a\nGeometryCollection value using its WKB representation and SRID
|
|
[ST_GEOMETRYN]
|
|
declaration=gc, N
|
|
category=GeometryCollection Property Functions
|
|
description=Returns the N-th geometry in the GeometryCollection value gc
|
|
[ST_GEOMETRYTYPE]
|
|
declaration=g
|
|
category=Geometry Property Functions
|
|
description=Returns a binary string indicating the name of the geometry type of which\nthe geometry instance g is a member
|
|
[ST_GEOMFROMGEOJSON]
|
|
declaration=str [, options [, srid]]
|
|
category=MBR Functions
|
|
description=Parses a string str representing a GeoJSON object and returns a geometry
|
|
[ST_GEOMFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=srid [, options]]) Constructs a geometry value of any type using its WKT\nrepresentation and SRID
|
|
[ST_GEOMFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=srid [, options]]) Constructs a geometry value of any type using its WKB\nrepresentation and SRID
|
|
[ST_HAUSDORFFDISTANCE]
|
|
declaration=g1, g2 [, unit]
|
|
category=Geometry Relation Functions
|
|
description=Returns the discrete Hausdorff distance between two geometries, reflecting\nhow similar the geometries are
|
|
[ST_INTERIORRINGN]
|
|
declaration=poly, N
|
|
category=Polygon Property Functions
|
|
description=Returns the N-th interior ring for the Polygon value poly as a LineString
|
|
[ST_INTERSECTION]
|
|
declaration=g1, g2
|
|
category=GeometryCollection Property Functions
|
|
description=Returns a geometry that represents the point set intersection of the\ngeometry values g1 and g2
|
|
[ST_INTERSECTS]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Returns 1 or 0 to indicate whether g1 spatially intersects g2
|
|
[ST_ISCLOSED]
|
|
declaration=ls
|
|
category=LineString Property Functions
|
|
description=For a LineString value ls, ST_IsClosed() returns 1 if ls is closed (that\nis, its ST_StartPoint() and ST_EndPoint() values are the same)
|
|
[ST_ISEMPTY]
|
|
declaration=g
|
|
category=Geometry Property Functions
|
|
description=This function is a placeholder that returns 1 for an empty geometry\ncollection value or 0 otherwise
|
|
[ST_ISSIMPLE]
|
|
declaration=g
|
|
category=Geometry Property Functions
|
|
description=Returns 1 if the geometry value g is simple according to the ISO SQL/MM\nPart 3: Spatial standard
|
|
[ST_ISVALID]
|
|
declaration=g
|
|
category=MBR Functions
|
|
description=Returns 1 if the argument is geometrically valid, 0 if the argument is not\ngeometrically valid
|
|
[ST_LATFROMGEOHASH]
|
|
declaration=geohash_str
|
|
category=MBR Functions
|
|
description=Returns the latitude from a geohash string value, as a double-precision\nnumber in the range [90, 90]
|
|
[ST_LATITUDE]
|
|
declaration=p [, new_latitude_val]
|
|
category=Point Property Functions
|
|
description=With a single argument representing a valid Point object p that has a\ngeographic spatial reference system (SRS), ST_Latitude() returns the\nlatitude value of p as a double-precision number
|
|
[ST_LENGTH]
|
|
declaration=ls [, unit]
|
|
category=LineString Property Functions
|
|
description=Returns a double-precision number indicating the length of the LineString\nor MultiLineString value ls in its associated spatial reference system
|
|
[ST_LINEFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=srid [, options]]) Constructs a LineString value using its WKT\nrepresentation and SRID
|
|
[ST_LINEFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=srid [, options]]) Constructs a LineString value using its WKB\nrepresentation and SRID
|
|
[ST_LINEINTERPOLATEPOINT]
|
|
declaration=ls, fractional_distance
|
|
category=GeometryCollection Property Functions
|
|
description=This function takes a LineString geometry and a fractional distance in the\nrange [0
|
|
[ST_LINEINTERPOLATEPOINTS]
|
|
declaration=ls, fractional_distance
|
|
category=GeometryCollection Property Functions
|
|
description=This function takes a LineString geometry and a fractional distance in the\nrange (0
|
|
[ST_LONGFROMGEOHASH]
|
|
declaration=geohash_str
|
|
category=MBR Functions
|
|
description=Returns the longitude from a geohash string value, as a double-precision\nnumber in the range [180, 180]
|
|
[ST_LONGITUDE]
|
|
declaration=p [, new_longitude_val]
|
|
category=Point Property Functions
|
|
description=With a single argument representing a valid Point object p that has a\ngeographic spatial reference system (SRS), ST_Longitude() returns the\nlongitude value of p as a double-precision number
|
|
[ST_MAKEENVELOPE]
|
|
declaration=pt1, pt2
|
|
category=MBR Functions
|
|
description=Returns the rectangle that forms the envelope around two points, as a\nPoint, LineString, or Polygon
|
|
[ST_MLINEFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=ST_MultiLineStringFromText(wkt [, srid [, options]]) Constructs a\nMultiLineString value using its WKT representation and SRID
|
|
[ST_MLINEFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=ST_MultiLineStringFromWKB(wkb [, srid [, options]]) Constructs a\nMultiLineString value using its WKB representation and SRID
|
|
[ST_MPOINTFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=[, srid [, options]]) Constructs a MultiPoint value using its WKT\nrepresentation and SRID
|
|
[ST_MPOINTFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=srid [, options]]) Constructs a MultiPoint value using its WKB\nrepresentation and SRID
|
|
[ST_MPOLYFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=[, srid [, options]]) Constructs a MultiPolygon value using its WKT\nrepresentation and SRID
|
|
[ST_MPOLYFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=[, srid [, options]]) Constructs a MultiPolygon value using its WKB\nrepresentation and SRID
|
|
[ST_NUMGEOMETRIES]
|
|
declaration=gc
|
|
category=GeometryCollection Property Functions
|
|
description=Returns the number of geometries in the GeometryCollection value gc
|
|
[ST_NUMPOINTS]
|
|
declaration=ls
|
|
category=LineString Property Functions
|
|
description=Returns the number of Point objects in the LineString value ls
|
|
[ST_OVERLAPS]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Two geometries spatially overlap if they intersect and their intersection\nresults in a geometry of the same dimension but not equal to either of the\ngiven geometries
|
|
[ST_POINTATDISTANCE]
|
|
declaration=ls, distance
|
|
category=GeometryCollection Property Functions
|
|
description=This function takes a LineString geometry and a distance in the range [0
|
|
[ST_POINTFROMGEOHASH]
|
|
declaration=geohash_str, srid
|
|
category=MBR Functions
|
|
description=Returns a POINT value containing the decoded geohash value, given a geohash\nstring value
|
|
[ST_POINTFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=Constructs a Point value using its WKT representation and SRID
|
|
[ST_POINTFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=Constructs a Point value using its WKB representation and SRID
|
|
[ST_POINTN]
|
|
declaration=ls, N
|
|
category=LineString Property Functions
|
|
description=Returns the N-th Point in the Linestring value ls
|
|
[ST_POLYFROMTEXT]
|
|
declaration=wkt [, srid [, options]]
|
|
category=WKT Functions
|
|
description=srid [, options]]) Constructs a Polygon value using its WKT representation\nand SRID
|
|
[ST_POLYFROMWKB]
|
|
declaration=wkb [, srid [, options]]
|
|
category=WKB Functions
|
|
description=[, options]]) Constructs a Polygon value using its WKB representation and\nSRID
|
|
[ST_SIMPLIFY]
|
|
declaration=g, max_distance
|
|
category=MBR Functions
|
|
description=Simplifies a geometry using the Douglas-Peucker algorithm and returns a\nsimplified value of the same type
|
|
[ST_SRID]
|
|
declaration=g [, srid]
|
|
category=Geometry Property Functions
|
|
description=With a single argument representing a valid geometry object g, ST_SRID()\nreturns an integer indicating the ID of the spatial reference system (SRS)\nassociated with g
|
|
[ST_STARTPOINT]
|
|
declaration=ls
|
|
category=LineString Property Functions
|
|
description=Returns the Point that is the start point of the LineString value ls
|
|
[ST_SWAPXY]
|
|
declaration=g
|
|
category=WKB Functions
|
|
description=Accepts an argument in internal geometry format, swaps the X and Y values\nof each coordinate pair within the geometry, and returns the result
|
|
[ST_SYMDIFFERENCE]
|
|
declaration=g1, g2
|
|
category=GeometryCollection Property Functions
|
|
description=Returns a geometry that represents the point set symmetric difference of\nthe geometry values g1 and g2, which is defined as: g1 symdifference g2 :=\n(g1 union g2) difference (g1 intersection g2) Or, in function call\nnotation: ST_SymDifference(g1, g2) = ST_Difference(ST_Union(g1, g2),\nST_Intersection(g1, g2)) ST_SymDifference() handles its arguments as\ndescribed in the introduction to this section
|
|
[ST_TOUCHES]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Two geometries spatially touch if their interiors do not intersect, but the\nboundary of one of the geometries intersects either the boundary or the\ninterior of the other
|
|
[ST_TRANSFORM]
|
|
declaration=g, target_srid
|
|
category=GeometryCollection Property Functions
|
|
description=Transforms a geometry from one spatial reference system (SRS) to another
|
|
[ST_UNION]
|
|
declaration=g1, g2
|
|
category=GeometryCollection Property Functions
|
|
description=Returns a geometry that represents the point set union of the geometry\nvalues g1 and g2
|
|
[ST_VALIDATE]
|
|
declaration=g
|
|
category=MBR Functions
|
|
description=Validates a geometry according to the OGC specification
|
|
[ST_WITHIN]
|
|
declaration=g1, g2
|
|
category=Geometry Relation Functions
|
|
description=Returns 1 or 0 to indicate whether g1 is spatially within g2
|
|
[ST_X]
|
|
declaration=p [, new_x_val]
|
|
category=Point Property Functions
|
|
description=With a single argument representing a valid Point object p, ST_X() returns\nthe X-coordinate value of p as a double-precision number
|
|
[ST_Y]
|
|
declaration=p [, new_y_val]
|
|
category=Point Property Functions
|
|
description=With a single argument representing a valid Point object p, ST_Y() returns\nthe Y-coordinate value of p as a double-precision number
|
|
[SUBDATE]
|
|
declaration=date,INTERVAL expr unit
|
|
category=Date and Time Functions
|
|
description=When invoked with the INTERVAL form of the second argument, SUBDATE() is a\nsynonym for DATE_SUB()
|
|
[SUBSTR]
|
|
declaration=str,pos
|
|
category=String Functions
|
|
description=FROM pos FOR len) SUBSTR() is a synonym for SUBSTRING()
|
|
[SUBSTRING]
|
|
declaration=str,pos
|
|
category=String Functions
|
|
description=SUBSTRING(str FROM pos FOR len) The forms without a len argument return a\nsubstring from string str starting at position pos
|
|
[SUBSTRING_INDEX]
|
|
declaration=str,delim,count
|
|
category=String Functions
|
|
description=Returns the substring from string str before count occurrences of the\ndelimiter delim
|
|
[SUBTIME]
|
|
declaration=expr1,expr2
|
|
category=Date and Time Functions
|
|
description=SUBTIME() returns expr1  expr2 expressed as a value in the same format\nas expr1
|
|
[SUM]
|
|
declaration=[DISTINCT] expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the sum of expr
|
|
[SYSDATE]
|
|
declaration=[fsp]
|
|
category=Date and Time Functions
|
|
description=Returns the current date and time as a value in 'YYYY-MM-DD hh:mm:ss' or\nYYYYMMDDhhmmss format, depending on whether the function is used in string\nor numeric context
|
|
[TAN]
|
|
declaration=X
|
|
category=Numeric Functions
|
|
description=Returns the tangent of X, where X is given in radians
|
|
[TIMEDIFF]
|
|
declaration=expr1,expr2
|
|
category=Date and Time Functions
|
|
description=TIMEDIFF() returns expr1  expr2 expressed as a time value
|
|
[TIMESTAMPADD]
|
|
declaration=unit,interval,datetime_expr
|
|
category=Date and Time Functions
|
|
description=Adds the integer expression interval to the date or datetime expression\ndatetime_expr
|
|
[TIMESTAMPDIFF]
|
|
declaration=unit,datetime_expr1,datetime_expr2
|
|
category=Date and Time Functions
|
|
description=Returns datetime_expr2 - datetime_expr1, where datetime_expr1 and\ndatetime_expr2 are date or datetime expressions
|
|
[TIME_FORMAT]
|
|
declaration=time,format
|
|
category=Date and Time Functions
|
|
description=This is used like the DATE_FORMAT() function, but the format string may\ncontain format specifiers only for hours, minutes, seconds, and\nmicroseconds
|
|
[TIME_TO_SEC]
|
|
declaration=time
|
|
category=Date and Time Functions
|
|
description=Returns the time argument, converted to seconds
|
|
[TO_BASE64]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Converts the string argument to base-64 encoded form and returns the result\nas a character string with the connection character set and collation
|
|
[TO_DAYS]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Given a date date, returns a day number (the number of days since year 0)
|
|
[TO_SECONDS]
|
|
declaration=expr
|
|
category=Date and Time Functions
|
|
description=Given a date or datetime expr, returns the number of seconds since the year\n0
|
|
[TRIM]
|
|
declaration=[{BOTH | LEADING | TRAILING} [remstr] FROM] str
|
|
category=String Functions
|
|
description=FROM] str) Returns the string str with all remstr prefixes or suffixes\nremoved
|
|
[TRUNCATE]
|
|
declaration=X,D
|
|
category=Numeric Functions
|
|
description=Returns the number X, truncated to D decimal places
|
|
[UCASE]
|
|
declaration=str
|
|
category=String Functions
|
|
description=UCASE() is a synonym for UPPER()
|
|
[UNCOMPRESS]
|
|
declaration=string_to_uncompress
|
|
category=Encryption Functions
|
|
description=Uncompresses a string compressed by the COMPRESS() function
|
|
[UNCOMPRESSED_LENGTH]
|
|
declaration=compressed_string
|
|
category=Encryption Functions
|
|
description=Returns the length that the compressed string had before being compressed
|
|
[UNHEX]
|
|
declaration=str
|
|
category=String Functions
|
|
description=For a string argument str, UNHEX(str) interprets each pair of characters in\nthe argument as a hexadecimal number and converts it to the byte\nrepresented by the number
|
|
[UNIX_TIMESTAMP]
|
|
declaration=[date]
|
|
category=Date and Time Functions
|
|
description=If UNIX_TIMESTAMP() is called with no date argument, it returns a Unix\ntimestamp representing seconds since '1970-01-01 00:00:00' UTC
|
|
[UPDATEXML]
|
|
declaration=xml_target, xpath_expr, new_xml
|
|
category=XML
|
|
description=This function replaces a single portion of a given fragment of XML markup\nxml_target with a new XML fragment new_xml, and then returns the changed\nXML
|
|
[UPPER]
|
|
declaration=str
|
|
category=String Functions
|
|
description=Returns the string str with all characters changed to uppercase according\nto the current character set mapping
|
|
[UUID_TO_BIN]
|
|
declaration=string_uuid
|
|
category=Miscellaneous Functions
|
|
description=Converts a string UUID to a binary UUID and returns the result
|
|
[VALIDATE_PASSWORD_STRENGTH]
|
|
declaration=str
|
|
category=Encryption Functions
|
|
description=Given an argument representing a plaintext password, this function returns\nan integer to indicate how strong the password is
|
|
[VALUES]
|
|
declaration=col_name
|
|
category=Miscellaneous Functions
|
|
description=In an INSERT
|
|
[VARBINARY]
|
|
declaration=M
|
|
category=Data Types
|
|
description=The VARBINARY type is similar to the VARCHAR type, but stores binary byte\nstrings rather than nonbinary character strings
|
|
[VARIANCE]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the population standard variance of expr
|
|
[VAR_POP]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the population standard variance of expr
|
|
[VAR_SAMP]
|
|
declaration=expr
|
|
category=Aggregate Functions and Modifiers
|
|
description=Returns the sample variance of expr
|
|
[WAIT_FOR_EXECUTED_GTID_SET]
|
|
declaration=gtid_set[, timeout]
|
|
category=GTID
|
|
description=Wait until the server has applied all of the transactions whose global\ntransaction identifiers are contained in gtid_set; that is, until the\ncondition GTID_SUBSET(gtid_subset, @@GLOBAL
|
|
[WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS]
|
|
declaration=gtid_set[, timeout][,channel]
|
|
category=GTID
|
|
description=WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() is deprecated
|
|
[WEEK]
|
|
declaration=date[,mode]
|
|
category=Date and Time Functions
|
|
description=This function returns the week number for date
|
|
[WEEKDAY]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the weekday index for date (0 = Monday, 1 = Tuesday,
|
|
[WEEKOFYEAR]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the calendar week of the date as a number in the range from 1 to 53
|
|
[WEIGHT_STRING]
|
|
declaration=str [AS {CHAR|BINARY}(N)] [flags]
|
|
category=String Functions
|
|
description=This function returns the weight string for the input string
|
|
[YEAR]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns the year for date, in the range 1000 to 9999, or 0 for the "zero"\ndate
|
|
[YEARWEEK]
|
|
declaration=date
|
|
category=Date and Time Functions
|
|
description=Returns year and week for a date
|