Auszug aus dem off. MySQL Handbuch! (z.B. auf dt. Kapitel 7.3)  



6.3 Functions for Use 
  in SELECT and WHERE Clauses


  


 A select_expression or where_definition in a SQL 
  statement can consist of any expression using the functions described below. 



 An expression that contains NULL always produces a NULL 
  value unless otherwise indicated in the documentation for the operators and 
  functions involved in the expression. 


 NOTE: There must be no whitespace between a function name 
  and the parenthesis following it. This helps the MySQL parser distinguish between 
  function calls and references to tables or columns that happen to have the same 
  name as a function. Spaces around arguments are permitted, though. 


 You can force MySQL to accept spaces after the function name by starting mysqld 
  with --ansi or using the CLIENT_IGNORE_SPACE to mysql_connect(), 
  but in this case all function names will become reserved words. See section 
  1.4.3 Running MySQL in ANSI Mode. 


 For the sake of brevity, examples display the output from the mysql 
  program in abbreviated form. So this: 


mysql> select MOD(29,9);
1 rows in set (0.00 sec)

+-----------+
| mod(29,9) |
+-----------+
|         2 |
+-----------+



 is displayed like this: 


mysql> select MOD(29,9);
        -> 2



6.3.1 
  Non-Type-Specific Operators and Functions


6.3.1.1 Parenthesis


   


   


( ... )



 Use parenthesis to force the order of evaluation in an expression. For example: 



mysql> select 1+2*3;
        -> 7
mysql> select (1+2)*3;
        -> 9



6.3.1.2 
  Comparison Operators


  


   


 Comparison operations result in a value of 1 (TRUE), 0 
  (FALSE), or NULL. These functions work for both numbers and strings. 
  Strings are automatically converted to numbers and numbers to strings as needed 
  (as in Perl). 


 MySQL performs comparisons using the following rules: 



 By default, string comparisons are done in case-independent fashion using 
  the current character set (ISO-8859-1 Latin1 by default, which also works excellently 
  for English). 


 The examples below illustrate conversion of strings to numbers for comparison 
  operations: 


mysql> SELECT 1 > '6x';
         -> 0
mysql> SELECT 7 > '6x';
         -> 1
mysql> SELECT 0 > 'x6';
         -> 0
mysql> SELECT 0 = 'x6';
         -> 1



 
  
= 
  
   Equal: 
    
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


        
  
<> 
  
 
  
!= 
  
 Not equal: 
    
mysql> select '.01' <> '0.01';
        -> 1
mysql> select .01 <> '0.01';
        -> 0
mysql> select 'zapp' <> 'zappp';
        -> 1


      
  
<= 
  
 Less than or equal: 
    
mysql> select 0.1 <= 2;
        -> 1


      
  
< 
  
 Less than: 
    
mysql> select 2 < 2;
        -> 0


      
  
>= 
  
 Greater than or equal: 
    
mysql> select 2 >= 2;
        -> 1


      
  
> 
  
 Greater than: 
    
mysql> select 2 > 2;
        -> 0


      
  
<=> 
  
 Null safe equal: 
    
mysql> select 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
        -> 1 1 0


       
  
IS NULL 
  
 
  
IS NOT NULL 
  
 Test whether or not a value is or is not NULL: 
    
mysql> select 1 IS NULL, 0 IS NULL, NULL IS NULL;
        -> 0 0 1
mysql> select 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
        -> 1 1 0


     
  
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. The first argument (expr) determines how the 
    comparison is performed as follows: 
    
    
      
  •  If expr is a TIMESTAMP, DATE, 
        or DATETIME column, MIN() and MAX() 
        are formatted to the same format if they are constants. 
      
  •  If expr is a case-insensitive string expression, a case-insensitive 
        string comparison is done. 
      
  •  If expr is a case-sensitive string expression, a case-sensitive 
        string comparison is done. 
      
  •  If expr is an integer expression, an integer comparison 
        is done. 
      
  •  Otherwise, a floating-point (real) comparison is done. 
    

    
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


     
  
expr IN (value,...) 
  
 Returns 1 if expr is any of the values in the 
    IN list, else returns 0. If all values are constants, 
    then all values are evaluated according to the type of expr and 
    sorted. The search for the item is then done using a binary search. This means 
    IN is very quick if the IN value list consists entirely 
    of constants. If expr is a case-sensitive string expression, 
    the string comparison is performed in case-sensitive fashion: 
    
mysql> select 2 IN (0,3,5,'wefwf');
        -> 0
mysql> select 'wefwf' IN (0,3,5,'wefwf');
        -> 1


     
  
expr NOT IN (value,...) 
  
 Same as NOT (expr IN (value,...)).  
  
ISNULL(expr) 
  
 If expr is NULL, ISNULL() returns 
    1, otherwise it returns 0: 
    
mysql> select ISNULL(1+1);
        -> 0
mysql> select ISNULL(1/0);
        -> 1


    Note that a comparison of NULL values using = will 
    always be false!   
  
COALESCE(list) 
  
 Returns first non-NULL element in list: 
    
mysql> select COALESCE(NULL,1);
        -> 1
mysql> select COALESCE(NULL,NULL,NULL);
        -> NULL


     
  
INTERVAL(N,N1,N2,N3,...) 
  
 Returns 0 if N < N1, 1 
    if N < N2 and so on. 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): 
    
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





 If you are comparing case sensitive string with any of the standard operators 
  (=, <>..., but not LIKE) end 
  space will be ignored. 


mysql> select "a" ="A ";
        -> 1



6.3.1.3 
  Logical Operators


   


 All logical functions return 1 (TRUE), 0 (FALSE) 
  or NULL (unknown, which is in most cases the same as FALSE): 


 
  
NOT 
  
   
  
! 
  
 Logical NOT. Returns 1 if the argument is 0, 
    otherwise returns 0. Exception: NOT NULL returns 
    NULL: 
    
mysql> select NOT 1;
        -> 0
mysql> select NOT NULL;
        -> NULL
mysql> select ! (1+1);
        -> 0
mysql> select ! 1+1;
        -> 1


    The last example returns 1 because the expression evaluates the 
    same way as (!1)+1.   
  
OR 
  
 
  
|| 
  
 Logical OR. Returns 1 if either argument is not 0 
    and not NULL: 
    
mysql> select 1 || 0;
        -> 1
mysql> select 0 || 0;
        -> 0
mysql> select 1 || NULL;
        -> 1



      
  
AND 
  
 
  
&& 
  
 Logical AND. Returns 0 if either argument is 0 
    or NULL, otherwise returns 1: 
    
mysql> select 1 && NULL;
        -> 0
mysql> select 1 && 0;
        -> 0





6.3.1.4 
  Control Flow Functions


   


 
  
IFNULL(expr1,expr2) 
  
   If expr1 is 
    not NULL, IFNULL() returns expr1, else 
    it returns expr2. IFNULL() returns a numeric or 
    string value, depending on the context in which it is used: 
    
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'


     
  
NULLIF(expr1,expr2) 
  
 If expr1 = expr2 is true, return NULL else return 
    expr1. This is the same as CASE WHEN x = y THEN NULL ELSE 
    x END: 
    
mysql> select NULLIF(1,1);
        -> NULL
mysql> select NULLIF(1,2);
        -> 1


    Note that expr1 is evaluated twice in MySQL if the arguments 
    are equal.  
  
IF(expr1,expr2,expr3) 
  
 If expr1 is TRUE (expr1 <> 0 and expr1 
    <> NULL) then IF() returns expr2, 
    else it returns expr3. IF() returns a numeric or 
    string value, depending on the context in which it is used: 
    
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'


    expr1 is evaluated as an integer value, which means that if you 
    are testing floating-point or string values, you should do so using a comparison 
    operation: 
    
mysql> select IF(0.1,1,0);
        -> 0
mysql> select IF(0.1<>0,1,0);
        -> 1


    In the first case above, IF(0.1) returns 0 because 
    0.1 is converted to an integer value, resulting in a test of 
    IF(0). This may not be what you expect. In the second case, the 
    comparison tests the original floating-point value to see whether it is non-zero. 
    The result of the comparison is used as an integer. The default return type 
    of IF() (which may matter when it is stored into a temporary 
    table) is calculated in MySQL Version 3.23 as follows: 
    

      

        Expression 
         Return value 
      

      

        expr2 or expr3 returns string 
         string 
      

      

        expr2 or expr3 returns a floating-point value 
         floating-point 
      

      

        expr2 or expr3 returns an integer 
         integer 
      

    

     
  
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, which is true. 
    If there was no matching result value, then the result after ELSE 
    is returned. If there is no ELSE part then NULL 
    is returned: 
    
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





 The type of the return value (INTEGER, DOUBLE or 
  STRING) is the same as the type of the first returned value (the 
  expression after the first THEN). 


6.3.2 String 
  Functions


   


 String-valued functions return NULL if the length of the result 
  would be greater than the max_allowed_packet server parameter. 
  See section 5.5.2 Tuning Server Parameters. 



 For functions that operate on string positions, the first position is numbered 
  1. 


 
  
ASCII(str) 
  
  Returns the ASCII code value of the leftmost character 
    of the string str. Returns 0 if str 
    is the empty string. Returns NULL if str is NULL: 
    
mysql> select ASCII('2');
        -> 50
mysql> select ASCII(2);
        -> 50
mysql> select ASCII('dx');
        -> 100


    See also the ORD() function.  
  
ORD(str) 
  
 If the leftmost character of the string str is a multi-byte character, 
    returns the code of multi-byte character by returning the ASCII code value 
    of the character in the format of: ((first byte ASCII code)*256+(second 
    byte ASCII code))[*256+third byte ASCII code...]. If the leftmost character 
    is not a multi-byte character, returns the same value as the like ASCII() 
    function does: 
    
mysql> select ORD('2');
        -> 50


     
  
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 to_base is a negative number, N 
    is regarded as a signed number. Otherwise, N is treated as unsigned. 
    CONV works with 64-bit precision: 
    
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'+0xa,10,10);
        -> '40'


     
  
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: 
    
mysql> select BIN(12);
        -> '1100'


     
  
OCT(N) 
  
 Returns a string representation of the octal value of N, where 
    N is a longlong number. This is equivalent to CONV(N,10,8). 
    Returns NULL if N is NULL: 
    
mysql> select OCT(12);
        -> '14'


     
  
HEX(N) 
  
 Returns a string representation of the hexadecimal value of N, 
    where N is a longlong (BIGINT) number. This is equivalent 
    to CONV(N,10,16). Returns NULL if N 
    is NULL: 
    
mysql> select HEX(255);
        -> 'FF'


     
  
CHAR(N,...) 
  
 CHAR() interprets the arguments as integers and returns a 
    string consisting of the characters given by the ASCII code values of those 
    integers. NULL values are skipped: 
    
mysql> select CHAR(77,121,83,81,'76');
        -> 'MySQL'
mysql> select CHAR(77,77.3,'77.3');
        -> 'MMM'


     
  
CONCAT(str1,str2,...) 
  
 Returns the string that results from concatenating the arguments. Returns 
    NULL if any argument is NULL. May have more than 
    2 arguments. A numeric argument is converted to the equivalent string form: 
    
mysql> select CONCAT('My', 'S', 'QL');
        -> 'MySQL'
mysql> select CONCAT('My', NULL, 'QL');
        -> NULL
mysql> select CONCAT(14.3);
        -> '14.3'


     
  
CONCAT_WS(separator, str1, str2,...) 
  
 CONCAT_WS() stands for CONCAT With Separator and is a special 
    form of CONCAT(). The first argument is the separator for the 
    rest of the arguments. The separator can be a string as well as the rest of 
    the arguments. If the separator is NULL, the result will be NULL. 
    The function will skip any NULLs and empty strings, after the 
    separator argument. The separator will be added between the strings to be 
    concatenated: 
    
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'


        
  
LENGTH(str) 
  
 
  
OCTET_LENGTH(str) 
  
 
  
CHAR_LENGTH(str) 
  
 
  
CHARACTER_LENGTH(str) 
  
 Returns the length of the string str: 
    
mysql> select LENGTH('text');
        -> 4
mysql> select OCTET_LENGTH('text');
        -> 4


    Note that for CHAR_LENGTH(), multi-byte characters are only counted 
    once.   
  
LOCATE(substr,str) 
  
 
  
POSITION(substr IN str) 
  
 Returns the position of the first occurrence of substring substr 
    in string str. Returns 0 if substr 
    is not in str: 
    
mysql> select LOCATE('bar', 'foobarbar');
        -> 4
mysql> select LOCATE('xbar', 'foobar');
        -> 0


    This function is multi-byte safe.  
  
LOCATE(substr,str,pos) 
  
 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: 
    
mysql> select LOCATE('bar', 'foobarbar',5);
        -> 7


    This function is multi-byte safe.  
  
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 arguments are swapped: 
    
mysql> select INSTR('foobarbar', 'bar');
        -> 4
mysql> select INSTR('xbar', 'foobar');
        -> 0


    This function is multi-byte safe.  
  
LPAD(str,len,padstr) 
  
 Returns the string str, left-padded with the string padstr 
    until str is len characters long. If str 
    is longer than len' then it will be shortened to len 
    characters. 
    
mysql> select LPAD('hi',4,'??');
        -> '??hi'


     
  
RPAD(str,len,padstr) 
  
 Returns the string str, right-padded with the string padstr 
    until str is len characters long. If str 
    is longer than len' then it will be shortened to len 
    characters. 
    
mysql> select RPAD('hi',5,'?');
        -> 'hi???'


     
  
LEFT(str,len) 
  
 Returns the leftmost len characters from the string str: 
    
mysql> select LEFT('foobarbar', 5);
        -> 'fooba'


    This function is multi-byte safe.  
  
RIGHT(str,len) 
  
 Returns the rightmost len characters from the string str: 
    
mysql> select RIGHT('foobarbar', 4);
        -> 'rbar'


    This function is multi-byte safe.   
  
SUBSTRING(str,pos,len) 
  
 
  
SUBSTRING(str FROM pos FOR len) 
  
 
  
MID(str,pos,len) 
  
 Returns a substring len characters long from string str, 
    starting at position pos. The variant form that uses FROM 
    is ANSI SQL92 syntax: 
    
mysql> select SUBSTRING('Quadratically',5,6);
        -> 'ratica'


    This function is multi-byte safe.  
  
SUBSTRING(str,pos) 
  
 
  
SUBSTRING(str FROM pos) 
  
 Returns a substring from string str starting at position pos: 
    
mysql> select SUBSTRING('Quadratically',5);
        -> 'ratically'
mysql> select SUBSTRING('foobarbar' FROM 4);
        -> 'barbar'


    This function is multi-byte safe.  
  
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: 
    
mysql> select SUBSTRING_INDEX('www.mysql.com', '.', 2);
        -> 'www.mysql'
mysql> select SUBSTRING_INDEX('www.mysql.com', '.', -2);
        -> 'mysql.com'


    This function is multi-byte safe.  
  
LTRIM(str) 
  
 Returns the string str with leading space characters removed: 
    
mysql> select LTRIM('  barbar');
        -> 'barbar'


     
  
RTRIM(str) 
  
 Returns the string str with trailing space characters removed: 
    
mysql> select RTRIM('barbar   ');
        -> 'barbar'


    This function is multi-byte safe.  
  
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str) 
  
 Returns the string str with all remstr prefixes 
    and/or suffixes removed. If none of the specifiers BOTH, LEADING 
    or TRAILING are given, BOTH is assumed. If remstr 
    is not specified, spaces are removed: 
    
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'


    This function is multi-byte safe.  
  
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 4 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 non-alphanumeric characters are ignored 
    in the given string. All international alpha characters outside the A-Z range 
    are treated as vowels: 
    
mysql> select SOUNDEX('Hello');
        -> 'H400'
mysql> select SOUNDEX('Quadratically');
        -> 'Q36324'


     
  
SPACE(N) 
  
 Returns a string consisting of N space characters: 
    
mysql> select SPACE(6);
        -> '      '


     
  
REPLACE(str,from_str,to_str) 
  
 Returns the string str with all all occurrences of the string 
    from_str replaced by the string to_str: 
    
mysql> select REPLACE('www.mysql.com', 'w', 'Ww');
        -> 'WwWwWw.mysql.com'


    This function is multi-byte safe.  
  
REPEAT(str,count) 
  
 Returns a string consisting of the string str repeated count 
    times. If count <= 0, returns an empty string. Returns NULL 
    if str or count are NULL: 
    
mysql> select REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'


     
  
REVERSE(str) 
  
 Returns the string str with the order of the characters reversed: 
    
mysql> select REVERSE('abc');
        -> 'cba'


    This function is multi-byte safe.  
  
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: 
    
mysql> select INSERT('Quadratic', 3, 4, 'What');
        -> 'QuWhattic'


    This function is multi-byte safe.  
  
ELT(N,str1,str2,str3,...) 
  
 Returns 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(): 
    
mysql> select ELT(1, 'ej', 'Heja', 'hej', 'foo');
        -> 'ej'
mysql> select ELT(4, 'ej', 'Heja', 'hej', 'foo');
        -> 'foo'


     
  
FIELD(str,str1,str2,str3,...) 
  
 Returns the index of str in the str1, str2, 
    str3, ... list. Returns 0 if str 
    is not found. FIELD() is the complement of ELT(): 
    
mysql> select FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 2
mysql> select FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 0


     
  
FIND_IN_SET(str,strlist) 
  
 Returns a value 1 to N if the string str 
    is in the 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 
    will not work properly if the first argument contains a `,': 
    
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
        -> 2


     
  
MAKE_SET(bits,str1,str2,...) 
  
 Returns a set (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, etc. 
    NULL strings in str1, str2, ... 
    are not appended to the result: 
    
mysql> SELECT MAKE_SET(1,'a','b','c');
        -> 'a'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
        -> 'hello,world'
mysql> SELECT MAKE_SET(0,'a','b','c');
        -> ''


     
  
EXPORT_SET(bits,on,off,[separator,[number_of_bits]]) 
  
 Returns a string where for every bit set in 'bit', you get an 'on' string 
    and for every reset bit you get an 'off' string. Each string is separated 
    with 'separator' (default ',') and only 'number_of_bits' (default 64) of 'bits' 
    is used: 
    
mysql> select EXPORT_SET(5,'Y','N',',',4)
        -> Y,N,Y,N


      
  
LCASE(str) 
  
 
  
LOWER(str) 
  
 Returns the string str with all characters changed to lowercase 
    according to the current character set mapping (the default is ISO-8859-1 
    Latin1): 
    
mysql> select LCASE('QUADRATICALLY');
        -> 'quadratically'


    This function is multi-byte safe.   
  
UCASE(str) 
  
 
  
UPPER(str) 
  
 Returns the string str with all characters changed to uppercase 
    according to the current character set mapping (the default is ISO-8859-1 
    Latin1): 
    
mysql> select UCASE('Hej');
        -> 'HEJ'


    This function is multi-byte safe.   
  
LOAD_FILE(file_name) 
  
 Reads the file and returns the file contents as a string. The file must 
    be on the server, you must specify the full pathname to the file, and you 
    must have the file privilege. The file must be readable by 
    all and be smaller than max_allowed_packet. If the file doesn't 
    exist or can't be read due to one of the above reasons, the function returns 
    NULL: 
    
mysql> UPDATE table_name
           SET blob_column=LOAD_FILE("/tmp/picture")
           WHERE id=1;





 If you are not using MySQL Version 3.23, you have to do the reading of the 
  file inside your application and create an INSERT statement to 
  update the database with the file information. One way to do this, if you are 
  using the MySQL++ library, can be found at http://www.mysql.com/documentation/mysql++/mysql++-examples.html. 



 MySQL automatically converts numbers to strings as necessary, and vice-versa: 



mysql> SELECT 1+"1";
        -> 2
mysql> SELECT CONCAT(2,' test');
        -> '2 test'



 If you want to convert a number to a string explicitly, pass it as the argument 
  to CONCAT(). 


 If a string function is given a binary string as an argument, the resulting 
  string is also a binary string. A number converted to a string is treated as 
  a binary string. This only affects comparisons. 


6.3.2.1 
  String Comparison Functions


   


   


 Normally, if any expression in a string comparison is case sensitive, the 
  comparison is performed in case-sensitive fashion. 


 
  
expr LIKE pat [ESCAPE 'escape-char'] 
  
  Pattern matching using SQL simple regular expression 
    comparison. Returns 1 (TRUE) or 0 (FALSE). With 
    LIKE you can use the following two wild-card characters in the 
    pattern: 
    

      

        % 
         Matches any number of characters, even zero characters 
      

      

        _ 
         Matches exactly one character 
      

    

    
mysql> select 'David!' LIKE 'David_';
        -> 1
mysql> select 'David!' LIKE '%D%v%';
        -> 1


    To test for literal instances of a wild-card character, precede the character 
    with the escape character. If you don't specify the ESCAPE character, 
    `\' is assumed: 
    

      

        \% 
         Matches one % character 
      

      

        \_ 
         Matches one _ character 
      

    

    
mysql> select 'David!' LIKE 'David\_';
        -> 0
mysql> select 'David_' LIKE 'David\_';
        -> 1


    To specify a different escape character, use the ESCAPE clause: 
    
mysql> select 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1


    The following two statements illustrate that string comparisons are case insensitive 
    unless one of the operands is a binary string: 
    
mysql> select 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0


    LIKE is allowed on numeric expressions! (This is a MySQL extension 
    to the ANSI SQL LIKE.) 
    
mysql> select 10 LIKE '1%';
        -> 1


    Note: Because MySQL uses the C escape syntax in strings (for example, `\n'), 
    you must double any `\' that you use in your LIKE 
    strings. For example, to search for `\n', specify it as `\\n'. 
    To search for `\', specify it as `\\\\' (the backslashes 
    are stripped once by the parser and another time when the pattern match is 
    done, leaving a single backslash to be matched).  
  
expr NOT LIKE pat [ESCAPE 'escape-char'] 
  
 Same as NOT (expr LIKE pat [ESCAPE 'escape-char']).  
       
  
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. 
    See section I Description of MySQL regular expression 
    syntax. Returns 1 if expr matches pat, 
    otherwise returns 0. RLIKE is a synonym for REGEXP, 
    provided for mSQL compatibility. Note: Because MySQL uses the 
    C escape syntax in strings (for example, `\n'), you must double 
    any `\' that you use in your REGEXP strings. As 
    of MySQL Version 3.23.4, REGEXP is case insensitive for normal 
    (not binary) strings: 
    
mysql> select 'Monty!' REGEXP 'm%y%%';
        -> 0
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


  
 
  
 REGEXP and RLIKE use the current character set 
    (ISO-8859-1 Latin1 by default) when deciding the type of a character.  
  
expr NOT REGEXP pat 
  
 
  
expr NOT RLIKE pat 
  
 Same as NOT (expr REGEXP pat).  
  
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: 
    
mysql> select STRCMP('text', 'text2');
        -> -1
mysql> select STRCMP('text2', 'text');
        -> 1
mysql> select STRCMP('text', 'text');
        -> 0


     
  
MATCH (col1,col2,...) AGAINST (expr) 
  
 MATCH ... AGAINST() is used for full-text search and returns 
    relevance - similarity measure between the text in columns (col1,col2,...) 
    and the query expr. Relevance is a positive floating-point number. 
    Zero relevance means no similarity. For MATCH ... AGAINST() to 
    work, a FULLTEXT index must be created first. See section 
    6.5.3 CREATE TABLE Syntax. 
    MATCH ... AGAINST() is available in MySQL Version 3.23.23 or 
    later. For details and usage examples see section 6.8 
    MySQL Full-text Search. 



6.3.2.2 
  Case Sensitivity


  


   


 
  
BINARY 
  
  The BINARY operator casts the string 
    following it to a binary string. This is an easy way to force a column comparison 
    to be case sensitive even if the column isn't defined as BINARY 
    or BLOB: 
    
mysql> select "a" = "A";
        -> 1
mysql> select BINARY "a" = "A";
        -> 0


    BINARY was introduced in MySQL Version 3.23.0. Note that in some 
    context MySQL will not be able to use the index efficiently when you cast 
    an indexed column to BINARY. 



 If you want to compare a blob case-insensitively you can always convert the 
  blob to upper case before doing the comparison: 


SELECT 'A' LIKE UPPER(blob_col) FROM table_name;



 We plan to soon introduce casting between different character sets to make 
  string comparison even more flexible. 


6.3.3 
  Numeric Functions


6.3.3.1 
  Arithmetic Operations


 The usual arithmetic operators are available. Note that in the case of `-', 
  `+', and `*', the result is calculated with BIGINT 
  (64-bit) precision if both arguments are integers! 


   

 
  
+ 
  
   Addition: 
    
mysql> select 3+5;
        -> 8


      
  
- 
  
 Subtraction: 
    
mysql> select 3-5;
        -> -2


      
  
* 
  
 Multiplication: 
    
mysql> select 3*5;
        -> 15
mysql> select 18014398509481984*18014398509481984.0;
        -> 324518553658426726783156020576256.0
mysql> select 18014398509481984*18014398509481984;
        -> 0


    The result of the last expression is incorrect because the result of the integer 
    multiplication exceeds the 64-bit range of BIGINT calculations. 
      
  
/ 
  
 Division: 
    
mysql> select 3/5;
        -> 0.60


    Division by zero produces a NULL result: 
    
mysql> select 102/(1-1);
        -> NULL


    A division will be calculated with BIGINT arithmetic only if 
    performed in a context where its result is converted to an integer! 



6.3.3.2 
  Mathematical Functions


 All mathematical functions return NULL in case of an error. 


   


 
  
- 
  
    Unary 
    minus. Changes the sign of the argument: 
    
mysql> select - 2;
        -> -2


    Note that if this operator is used with a BIGINT, the return 
    value is a BIGINT! This means that you should avoid using - 
    on integers that may have the value of -2^63!  
  
ABS(X) 
  
 Returns the absolute value of X: 
    
mysql> select ABS(2);
        -> 2
mysql> select ABS(-32);
        -> 32


    This function is safe to use with BIGINT values.  
  
SIGN(X) 
  
 Returns the sign of the argument as -1, 0, or 
    1, depending on whether X is negative, zero, or 
    positive: 
    
mysql> select SIGN(-32);
        -> -1
mysql> select SIGN(0);
        -> 0
mysql> select SIGN(234);
        -> 1


       
  
MOD(N,M) 
  
 
  
% 
  
 Modulo (like the % operator in C). Returns the remainder of 
    N divided by M: 
    
mysql> select MOD(234, 10);
        -> 4
mysql> select 253 % 7;
        -> 1
mysql> select MOD(29,9);
        -> 2


    This function is safe to use with BIGINT values.  
  
FLOOR(X) 
  
 Returns the largest integer value not greater than X: 
    
mysql> select FLOOR(1.23);
        -> 1
mysql> select FLOOR(-1.23);
        -> -2


    Note that the return value is converted to a BIGINT!  
  
CEILING(X) 
  
 Returns the smallest integer value not less than X: 
    
mysql> select CEILING(1.23);
        -> 2
mysql> select CEILING(-1.23);
        -> -1


    Note that the return value is converted to a BIGINT!  
  
ROUND(X) 
  
 Returns the argument X, rounded to the nearest integer: 
    
mysql> select ROUND(-1.23);
        -> -1
mysql> select ROUND(-1.58);
        -> -2
mysql> select ROUND(1.58);
        -> 2


    Note that the behavior of ROUND() when the argument is half way 
    between two integers depends on the C library implementation. Some round to 
    the nearest even number, always up, always down, or always towards zero. If 
    you need one kind of rounding, you should use a well-defined function like 
    TRUNCATE() or FLOOR() instead.  
  
ROUND(X,D) 
  
 Returns the argument X, rounded to a number with D 
    decimals. If D is 0, the result will have no decimal 
    point or fractional part: 
    
mysql> select ROUND(1.298, 1);
        -> 1.3
mysql> select ROUND(1.298, 0);
        -> 1


     
  
EXP(X) 
  
 Returns the value of e (the base of natural logarithms) raised 
    to the power of X: 
    
mysql> select EXP(2);
        -> 7.389056
mysql> select EXP(-2);
        -> 0.135335


     
  
LOG(X) 
  
 Returns the natural logarithm of X: 
    
mysql> select LOG(2);
        -> 0.693147
mysql> select LOG(-2);
        -> NULL


    If you want the log of a number X to some arbitary base B, 
    use the formula LOG(X)/LOG(B).  
  
LOG10(X) 
  
 Returns the base-10 logarithm of X: 
    
mysql> select LOG10(2);
        -> 0.301030
mysql> select LOG10(100);
        -> 2.000000
mysql> select LOG10(-100);
        -> NULL


      
  
POW(X,Y) 
  
 
  
POWER(X,Y) 
  
 Returns the value of X raised to the power of Y: 
    
mysql> select POW(2,2);
        -> 4.000000
mysql> select POW(2,-2);
        -> 0.250000


     
  
SQRT(X) 
  
 Returns the non-negative square root of X: 
    
mysql> select SQRT(4);
        -> 2.000000
mysql> select SQRT(20);
        -> 4.472136


     
  
PI() 
  
 Returns the value of PI. The default shown number of decimals is 5, but 
    MySQL internally uses the full double precession for PI. 
    
mysql> select PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793116


     
  
COS(X) 
  
 Returns the cosine of X, where X is given in 
    radians: 
    
mysql> select COS(PI());
        -> -1.000000


     
  
SIN(X) 
  
 Returns the sine of X, where X is given in radians: 
    
mysql> select SIN(PI());
        -> 0.000000


     
  
TAN(X) 
  
 Returns the tangent of X, where X is given in 
    radians: 
    
mysql> select TAN(PI()+1);
        -> 1.557408


     
  
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: 
    
mysql> select ACOS(1);
        -> 0.000000
mysql> select ACOS(1.0001);
        -> NULL
mysql> select ACOS(0);
        -> 1.570796


     
  
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: 
    
mysql> select ASIN(0.2);
        -> 0.201358
mysql> select ASIN('foo');
        -> 0.000000


     
  
ATAN(X) 
  
 Returns the arc tangent of X, that is, the value whose tangent 
    is X: 
    
mysql> select ATAN(2);
        -> 1.107149
mysql> select ATAN(-2);
        -> -1.107149


     
  
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: 
    
mysql> select ATAN(-2,2);
        -> -0.785398
mysql> select ATAN2(PI(),0);
        -> 1.570796


     
  
COT(X) 
  
 Returns the cotangent of X: 
    
mysql> select COT(12);
        -> -1.57267341
mysql> select COT(0);
        -> NULL


     
  
RAND() 
  
 
  
RAND(N) 
  
 Returns a random floating-point value in the range 0 to 1.0. 
    If an integer argument N is specified, it is used as the seed 
    value: 
    
mysql> select RAND();
        -> 0.5925
mysql> select RAND(20);
        -> 0.1811
mysql> select RAND(20);
        -> 0.1811
mysql> select RAND();
        -> 0.2079
mysql> select RAND();
        -> 0.7888


    You can't use a column with RAND() values in an ORDER BY 
    clause, because ORDER BY would evaluate the column multiple times. 
    In MySQL Version 3.23, you can, however, do: SELECT * FROM table_name 
    ORDER BY RAND() This is useful to get a random sample of a set SELECT 
    * FROM table1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000. 
    Note that a RAND() in a WHERE clause will be re-evaluated 
    every time the WHERE is executed.  
  
LEAST(X,Y,...) 
  
 With two or more arguments, returns the smallest (minimum-valued) argument. 
    The arguments are compared using the following rules: 
    
    
      
  •  If the return value is used in an INTEGER context, or 
        all arguments are integer-valued, they are compared as integers. 
      
  •  If the return value is used in a REAL context, or all 
        arguments are real-valued, they are compared as reals. 
      
  •  If any argument is a case-sensitive string, the arguments are compared 
        as case-sensitive strings. 
      
  •  In other cases, the arguments are compared as case-insensitive strings: 
    

    
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"


    In MySQL versions prior to Version 3.22.5, you can use MIN() 
    instead of LEAST.  
  
GREATEST(X,Y,...) 
  
 Returns the largest (maximum-valued) argument. The arguments are compared 
    using the same rules as for LEAST: 
    
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"


    In MySQL versions prior to Version 3.22.5, you can use MAX() 
    instead of GREATEST.  
  
DEGREES(X) 
  
 Returns the argument X, converted from radians to degrees: 
    
mysql> select DEGREES(PI());
        -> 180.000000


     
  
RADIANS(X) 
  
 Returns the argument X, converted from degrees to radians: 
    
mysql> select RADIANS(90);
        -> 1.570796


     
  
TRUNCATE(X,D) 
  
 Returns the number X, truncated to D decimals. 
    If D is 0, the result will have no decimal point 
    or fractional part: 
    
mysql> select TRUNCATE(1.223,1);
        -> 1.2
mysql> select TRUNCATE(1.999,1);
        -> 1.9
mysql> select TRUNCATE(1.999,0);
        -> 1


    Note that as decimal numbers are normally not stored as exact numbers in computers, 
    but as double values, you may be fooled by the following result:  
    
mysql> select TRUNCATE(10.28*100,0);
       -> 1027


    The above happens because 10.28 is actually stored as something like 10.2799999999999999. 



6.3.4 
  Date and Time Functions


   


 See section 6.2.2 Date and Time 
  Types for a description of the range of values each type has and the valid 
  formats in which date and time values may be specified. 


 Here is an example that uses date functions. The query below selects all records 
  with a date_col value from within the last 30 days: 


mysql> SELECT something FROM table
           WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;



 
  
DAYOFWEEK(date) 
  
  Returns the weekday index for date 
    (1 = Sunday, 2 = Monday, ... 7 = Saturday). 
    These index values correspond to the ODBC standard: 
    
mysql> select DAYOFWEEK('1998-02-03');
        -> 3


     
  
WEEKDAY(date) 
  
 Returns the weekday index for date (0 = Monday, 
    1 = Tuesday, ... 6 = Sunday): 
    
mysql> select WEEKDAY('1997-10-04 22:23:00');
        -> 5
mysql> select WEEKDAY('1997-11-05');
        -> 2


     
  
DAYOFMONTH(date) 
  
 Returns the day of the month for date, in the range 1 
    to 31: 
    
mysql> select DAYOFMONTH('1998-02-03');
        -> 3


     
  
DAYOFYEAR(date) 
  
 Returns the day of the year for date, in the range 1 
    to 366: 
    
mysql> select DAYOFYEAR('1998-02-03');
        -> 34


     
  
MONTH(date) 
  
 Returns the month for date, in the range 1 to 
    12: 
    
mysql> select MONTH('1998-02-03');
        -> 2


     
  
DAYNAME(date) 
  
 Returns the name of the weekday for date: 
    
mysql> select DAYNAME("1998-02-05");
        -> 'Thursday'


     
  
MONTHNAME(date) 
  
 Returns the name of the month for date: 
    
mysql> select MONTHNAME("1998-02-05");
        -> 'February'


     
  
QUARTER(date) 
  
 Returns the quarter of the year for date, in the range 1 
    to 4: 
    
mysql> select QUARTER('98-04-01');
        -> 2


     
  
WEEK(date) 
  
 
  
WEEK(date,first) 
  
 With a single argument, returns the week for date, in the 
    range 0 to 53 (yes, there may be the beginnings 
    of a week 53), for locations where Sunday is the first day of the week. The 
    two-argument form of WEEK() allows you to specify whether the 
    week starts on Sunday or Monday. The week starts on Sunday if the second argument 
    is 0, on Monday if the second argument is 1: 
    
mysql> select WEEK('1998-02-20');
        -> 7
mysql> select WEEK('1998-02-20',0);
        -> 7
mysql> select WEEK('1998-02-20',1);
        -> 8
mysql> select WEEK('1998-12-31',1);
        -> 53


     
  
YEAR(date) 
  
 Returns the year for date, in the range 1000 
    to 9999: 
    
mysql> select YEAR('98-02-03');
        -> 1998


  
YEARWEEK(date) 
  
 
  
YEARWEEK(date,first) 
  
 Returns year and week for a date. The second arguments works exactly like 
    the second argument to WEEK(). Note that the year may be different 
    from the year in the date argument for the first and the last week of the 
    year: 
    
mysql> select YEARWEEK('1987-01-01');
        -> 198653


     
  
HOUR(time) 
  
 Returns the hour for time, in the range 0 to 
    23: 
    
mysql> select HOUR('10:05:03');
        -> 10


     
  
MINUTE(time) 
  
 Returns the minute for time, in the range 0 to 
    59: 
    
mysql> select MINUTE('98-02-03 10:05:03');
        -> 5


     
  
SECOND(time) 
  
 Returns the second for time, in the range 0 to 
    59: 
    
mysql> select SECOND('10:05:03');
        -> 3


     
  
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: 
    
mysql> select PERIOD_ADD(9801,2);
        -> 199803


     
  
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: 
    
mysql> select PERIOD_DIFF(9802,199703);
        -> 11


        
     
  
DATE_ADD(date,INTERVAL expr type) 
  
 
  
DATE_SUB(date,INTERVAL expr type) 
  
 
  
ADDDATE(date,INTERVAL expr type) 
  
 
  
SUBDATE(date,INTERVAL expr type) 
  
 These functions perform date arithmetic. They are new for MySQL Version 
    3.22. ADDDATE() and SUBDATE() are synonyms for DATE_ADD() 
    and DATE_SUB(). In MySQL Version 3.23, you can use + 
    and - instead of DATE_ADD() and DATE_SUB() 
    if the expression on the right side is a date or datetime column. (See example) 
    date is a DATETIME or DATE value specifying 
    the starting date. 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. 
    type is a keyword indicating how the expression should be interpreted. 
    The related function EXTRACT(type FROM date) returns the 'type' 
    interval from the date. The following table shows how the type 
    and expr arguments are related: 
    

      

        type value 
         Expected expr format 
        
      

      

        SECOND 
         SECONDS 
      

      

        MINUTE 
         MINUTES 
      

      

        HOUR 
         HOURS 
      

      

        DAY 
         DAYS 
      

      

        MONTH 
         MONTHS 
      

      

        YEAR 
         YEARS 
      

      

        MINUTE_SECOND 
         "MINUTES:SECONDS" 
      

      

        HOUR_MINUTE 
         "HOURS:MINUTES" 
      

      

        DAY_HOUR 
         "DAYS HOURS" 
      

      

        YEAR_MONTH 
         "YEARS-MONTHS" 
      

      

        HOUR_SECOND 
         "HOURS:MINUTES:SECONDS" 
      

      

        DAY_MINUTE 
         "DAYS HOURS:MINUTES" 
      

      

        DAY_SECOND 
         "DAYS HOURS:MINUTES:SECONDS" 
      

    

    MySQL allows any punctuation delimiter in the expr format. Those 
    shown in the table are the suggested delimiters. If the date 
    argument is a DATE value and your calculations involve only YEAR, 
    MONTH, and DAY parts (that is, no time parts), the 
    result is a DATE value. Otherwise the result is a DATETIME 
    value: 
    
mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;
        -> 1998-01-01 00:00:00
mysql> SELECT INTERVAL 1 DAY + "1997-12-31";
        -> 1998-01-01
mysql> SELECT "1998-01-01" - INTERVAL 1 SECOND;
       -> 1997-12-31 23:59:59
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
                       INTERVAL 1 SECOND);
        -> 1998-01-01 00:00:00
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
                       INTERVAL 1 DAY);
        -> 1998-01-01 23:59:59
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
                       INTERVAL "1:1" MINUTE_SECOND);
        -> 1998-01-01 00:01:00
mysql> SELECT DATE_SUB("1998-01-01 00:00:00",
                       INTERVAL "1 1:1:1" DAY_SECOND);
        -> 1997-12-30 22:58:59
mysql> SELECT DATE_ADD("1998-01-01 00:00:00",
                       INTERVAL "-1 10" DAY_HOUR);
        -> 1997-12-30 14:00:00
mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);
        -> 1997-12-02


    If you specify an interval value that is too short (does not include all the 
    interval parts that would be expected from the type keyword), 
    MySQL assumes you have left out the leftmost parts of the interval value. 
    For example, if you specify a type of DAY_SECOND, 
    the value of expr is expected to have days, hours, minutes, and 
    seconds parts. If you specify a value like "1:10", MySQL assumes 
    that the days and hours parts are missing and the value represents minutes 
    and seconds. In other words, "1:10" DAY_SECOND is interpreted 
    in such a way that it is equivalent to "1:10" MINUTE_SECOND. 
    This is analogous to the way that MySQL interprets TIME values 
    as representing elapsed time rather than as time of day. Note that if you 
    add or subtract a date value against something that contains a time part, 
    the date value will be automatically converted to a datetime value: 
    
mysql> select date_add("1999-01-01", interval 1 day);
       -> 1999-01-02
mysql> select date_add("1999-01-01", interval 1 hour);
       -> 1999-01-01 01:00:00


    If you use really incorrect dates, the result is NULL. If you 
    add MONTH, YEAR_MONTH, or YEAR and 
    the resulting date has a day that is larger than the maximum day for the new 
    month, the day is adjusted to the maximum days in the new month: 
    
mysql> select DATE_ADD('1998-01-30', Interval 1 month);
        -> 1998-02-28


    Note from the preceding example that the word INTERVAL and the 
    type keyword are not case sensitive.  
  
EXTRACT(type FROM date) 
  
 The EXTRACT() function uses the same kinds of interval type 
    specifiers as DATE_ADD() or DATE_SUB(), but extracts 
    parts from the date rather than performing date arithmetic. 
    
mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");
       -> 1999
mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");
       -> 199907
mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");
       -> 20102


     
  
TO_DAYS(date) 
  
 Given a date date, returns a daynumber (the number of days 
    since year 0): 
    
mysql> select TO_DAYS(950501);
        -> 728779
mysql> select TO_DAYS('1997-10-07');
        -> 729669


    TO_DAYS() is not intended for use with values that precede the 
    advent of the Gregorian calendar (1582), because it doesn't take into account 
    the days that were lost when the calendar was changed.  
  
FROM_DAYS(N) 
  
 Given a daynumber N, returns a DATE value: 
    
mysql> select FROM_DAYS(729669);
        -> '1997-10-07'


    FROM_DAYS() is not intended for use with values that precede 
    the advent of the Gregorian calendar (1582), because it doesn't take into 
    account the days that were lost when the calendar was changed.  
  
DATE_FORMAT(date,format) 
  
 Formats the date value according to the format 
    string. The following specifiers may be used in the format string: 
    

      

        %M 
         Month name (January..December) 
      

      

        %W 
         Weekday name (Sunday..Saturday) 
      

      

        %D 
         Day of the month with English suffix (1st, 2nd, 
          3rd, etc.) 
      

      

        %Y 
         Year, numeric, 4 digits 
      

      

        %y 
         Year, numeric, 2 digits 
      

      

        %X 
         Year for the week where Sunday is the first day of the week, numeric, 
          4 digits, used with '%V' 
      

      

        %x 
         Year for the week, where Monday is the first day of the week, numeric, 
          4 digits, used with '%v' 
      

      

        %a 
         Abbreviated weekday name (Sun..Sat) 
      

      

        %d 
         Day of the month, numeric (00..31) 
      

      

        %e 
         Day of the month, numeric (0..31) 
      

      

        %m 
         Month, numeric (01..12) 
      

      

        %c 
         Month, numeric (1..12) 
      

      

        %b 
         Abbreviated month name (Jan..Dec) 
      

      

        %j 
         Day of year (001..366) 
      

      

        %H 
         Hour (00..23) 
      

      

        %k 
         Hour (0..23) 
      

      

        %h 
         Hour (01..12) 
      

      

        %I 
         Hour (01..12) 
      

      

        %l 
         Hour (1..12) 
      

      

        %i 
         Minutes, numeric (00..59) 
      

      

        %r 
         Time, 12-hour (hh:mm:ss [AP]M) 
      

      

        %T 
         Time, 24-hour (hh:mm:ss) 
      

      

        %S 
         Seconds (00..59) 
      

      

        %s 
         Seconds (00..59) 
      

      

        %p 
         AM or PM 
      

      

        %w 
         Day of the week (0=Sunday..6=Saturday) 
        
      

      

        %U 
         Week (0..53), where Sunday is the first 
          day of the week 
      

      

        %u 
         Week (0..53), where Monday is the first 
          day of the week 
      

      

        %V 
         Week (1..53), where Sunday is the first 
          day of the week. Used with '%X' 
      

      

        %v 
         Week (1..53), where Monday is the first 
          day of the week. Used with '%x' 
      

      

        %% 
         A literal `%'. 
      

    

    All other characters are just copied to the result without interpretation: 
    
mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
        -> 'Saturday October 1997'
mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
        -> '22:23:00'
mysql> select DATE_FORMAT('1997-10-04 22:23:00',
                          '%D %y %a %d %m %b %j');
        -> '4th 97 Sat 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'


    As of MySQL Version 3.23, the `%' character is required before 
    format specifier characters. In earlier versions of MySQL, `%' 
    was optional.  
  
TIME_FORMAT(time,format) 
  
 This is used like the DATE_FORMAT() function above, but the 
    format string may contain only those format specifiers that handle 
    hours, minutes, and seconds. Other specifiers produce a NULL 
    value or 0.   
  
CURDATE() 
  
 
  
CURRENT_DATE 
  
 Returns today's date as a value in 'YYYY-MM-DD' or YYYYMMDD 
    format, depending on whether the function is used in a string or numeric context: 
    
mysql> select CURDATE();
        -> '1997-12-15'
mysql> select CURDATE() + 0;
        -> 19971215


      
  
CURTIME() 
  
 
  
CURRENT_TIME 
  
 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: 
    
mysql> select CURTIME();
        -> '23:50:26'
mysql> select CURTIME() + 0;
        -> 235026


       
  
NOW() 
  
 
  
SYSDATE() 
  
 
  
CURRENT_TIMESTAMP 
  
 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: 
    
mysql> select NOW();
        -> '1997-12-15 23:50:26'
mysql> select NOW() + 0;
        -> 19971215235026


     
  
UNIX_TIMESTAMP() 
  
 
  
UNIX_TIMESTAMP(date) 
  
 If called with no argument, returns a Unix timestamp (seconds since '1970-01-01 
    00:00:00' GMT). 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' GMT. date may be a DATE string, 
    a DATETIME string, a TIMESTAMP, or a number in the 
    format YYMMDD or YYYYMMDD in local time: 
    
mysql> select UNIX_TIMESTAMP();
        -> 882226357
mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00');
        -> 875996580


    When UNIX_TIMESTAMP is used on a TIMESTAMP column, 
    the function will receive the value directly, with no implicit ``string-to-unix-timestamp'' 
    conversion. If you give UNIX_TIMESTAMP() a wrong or out-of-range 
    date, it will return 0.  
  
FROM_UNIXTIME(unix_timestamp) 
  
 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: 
    
mysql> select FROM_UNIXTIME(875996580);
        -> '1997-10-04 22:23:00'
mysql> select FROM_UNIXTIME(875996580) + 0;
        -> 19971004222300


     
  
FROM_UNIXTIME(unix_timestamp,format) 
  
 Returns a string representation of the Unix timestamp, formatted according 
    to the format string. format may contain the same 
    specifiers as those listed in the entry for the DATE_FORMAT() 
    function: 
    
mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),
                            '%Y %D %M %h:%i:%s %x');
        -> '1997 23rd December 03:43:30 x'


     
  
SEC_TO_TIME(seconds) 
  
 Returns the seconds argument, converted to hours, minutes, 
    and seconds, as a value in 'HH:MM:SS' or HHMMSS 
    format, depending on whether the function is used in a string or numeric context: 
    
mysql> select SEC_TO_TIME(2378);
        -> '00:39:38'
mysql> select SEC_TO_TIME(2378) + 0;
        -> 3938


     
  
TIME_TO_SEC(time) 
  
 Returns the time argument, converted to seconds: 
    
mysql> select TIME_TO_SEC('22:23:00');
        -> 80580
mysql> select TIME_TO_SEC('00:39:38');
        -> 2378





6.3.5 Other 
  Functions


6.3.5.1 Bit Functions


     



 MySQL uses BIGINT (64-bit) arithmetic for bit operations, so 
  these operators have a maximum range of 64 bits. 


 
  
| 
  
   Bitwise OR: 
    
mysql> select 29 | 15;
        -> 31


      
  
& 
  
 Bitwise AND: 
    
mysql> select 29 & 15;
        -> 13


     
  
<< 
  
 Shifts a longlong (BIGINT) number to the left: 
    
mysql> select 1 << 2;
        -> 4


     
  
>> 
  
 Shifts a longlong (BIGINT) number to the right: 
    
mysql> select 4 >> 2;
        -> 1


     
  
~ 
  
 Invert all bits: 
    
mysql> select 5 & ~1;
        -> 4


     
  
BIT_COUNT(N) 
  
 Returns the number of bits that are set in the argument N: 
    
mysql> select BIT_COUNT(29);
        -> 4





6.3.5.2 
  Miscellaneous Functions


   


 
  
DATABASE() 
  
  Returns the current database name: 
    
mysql> select DATABASE();
        -> 'test'


    If there is no current database, DATABASE() returns the empty 
    string.    
  
USER() 
  
 
  
SYSTEM_USER() 
  
 
  
SESSION_USER() 
  
 Returns the current MySQL user name: 
    
mysql> select USER();
        -> 'davida@localhost'


    In MySQL Version 3.22.11 or later, this includes the client hostname as well 
    as the user name. You can extract just the user name part like this (which 
    works whether or not the value includes a hostname part): 
    
mysql> select substring_index(USER(),"@",1);
        -> 'davida'


     
  
PASSWORD(str) 
  
 Calculates a password string from the plaintext password str. 
    This is the function that is used for encrypting MySQL passwords for storage 
    in the Password column of the user grant table: 
    
mysql> select PASSWORD('badpwd');
        -> '7f84554057dd964b'


     PASSWORD() encryption is non-reversible. 
    PASSWORD() does not perform password encryption in the same way 
    that Unix passwords are encrypted. You should not assume that if your Unix 
    password and your MySQL password are the same, PASSWORD() will 
    result in the same encrypted value as is stored in the Unix password file. 
    See ENCRYPT().  
  
ENCRYPT(str[,salt]) 
  
 Encrypt str using the Unix crypt() system call. 
    The salt argument should be a string with two characters. (As 
    of MySQL Version 3.22.16, salt may be longer than two characters.): 
    
mysql> select ENCRYPT("hello");
        -> 'VxuFAJXVARROc'


    If crypt() is not available on your system, ENCRYPT() 
    always returns NULL. ENCRYPT() ignores all but the 
    first 8 characters of str, at least on some systems. This will 
    be determined by the behavior of the underlying crypt() system 
    call.  
  
ENCODE(str,pass_str) 
  
 Encrypt str using pass_str as the password. To 
    decrypt the result, use DECODE(). The results is a binary string 
    of the same length as string. If you want to save it in a column, 
    use a BLOB column type.  
  
DECODE(crypt_str,pass_str) 
  
 Descrypts the encrypted string crypt_str using pass_str 
    as the password. crypt_str should be a string returned from ENCODE(). 
     
  
MD5(string) 
  
 Calculates a MD5 checksum for the string. Value is returned as a 32 long 
    hex number that may, for example, be used as a hash key: 
    
mysql> select MD5("testing");
        -> 'ae2b1fca515949e5d54fb22b8ed95575'


    This is an "RSA Data Security, Inc. MD5 Message-Digest Algorithm".  
  
LAST_INSERT_ID([expr]) 
  
 Returns the last automatically generated value that was inserted into an 
    AUTO_INCREMENT column. See section 8.4.3.126 
    mysql_insert_id(). 
    
mysql> select LAST_INSERT_ID();
        -> 195


    The last ID that was generated is maintained in the server on a per-connection 
    basis. It will not be changed by another client. It will not even be changed 
    if you update another AUTO_INCREMENT column with a non-magic 
    value (that is, a value that is not NULL and not 0). 
    If you insert many rows at the same time with an insert statement, LAST_INSERT_ID() 
    returns the value for the first inserted row. The reason for this is so that 
    you it makes it possible to easily reproduce the same INSERT 
    statement against some other server.  If expr 
    is given as an argument to LAST_INSERT_ID(), then the value of 
    the argument is returned by the function, is set as the next value to be returned 
    by LAST_INSERT_ID() and used as the next auto_increment value. 
    This can be used to simulate sequences: First create the table: 
    
mysql> create table sequence (id int not null);
mysql> insert into sequence values (0);


    Then the table can be used to generate sequence numbers like this: 
    
mysql> update sequence set id=LAST_INSERT_ID(id+1);


    You can generate sequences without calling LAST_INSERT_ID(), 
    but the utility of using the function this way is that the ID value is maintained 
    in the server as the last automatically generated value. You can retrieve 
    the new ID as you would read any normal AUTO_INCREMENT value 
    in MySQL. For example, LAST_INSERT_ID() (without an argument) 
    will return the new ID. The C API function mysql_insert_id() 
    can also be used to get the value. Note that as mysql_insert_id() 
    is only updated after INSERT and UPDATE statements, 
    you can't use this function to retrieve the value for LAST_INSERT_ID(expr) 
    after executing other SQL statements like SELECT or SET. 
     
  
FORMAT(X,D) 
  
 Formats the number X to a format like '#,###,###.##', 
    rounded to D decimals. If D is 0, the 
    result will have no decimal point or fractional part: 
    
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'


     
  
VERSION() 
  
 Returns a string indicating the MySQL server version: 
    
mysql> select VERSION();
        -> '3.23.13-log'


    Note that if your version ends with -log this means that logging 
    is enabled.  
  
CONNECTION_ID() 
  
 Returns the connection id (thread_id) for the connection. 
    Every connection has its own unique id: 
    
mysql> select CONNECTION_ID();
        -> 1


      
  
GET_LOCK(str,timeout) 
  
 Tries to obtain a lock with a name given by the string str, 
    with a timeout of timeout seconds. Returns 1 if 
    the lock was obtained successfully, 0 if the attempt timed out, 
    or NULL if an error occurred (such as running out of memory or 
    the thread was killed with mysqladmin kill). A lock is released 
    when you execute RELEASE_LOCK(), execute a new GET_LOCK(), 
    or the thread terminates. This function can be used to implement application 
    locks or to simulate record locks. It blocks requests by other clients for 
    locks with the same name; clients that agree on a given lock string name can 
    use the string to perform cooperative advisory locking: 
    
mysql> select GET_LOCK("lock1",10);
        -> 1
mysql> select GET_LOCK("lock2",10);
        -> 1
mysql> select RELEASE_LOCK("lock2");
        -> 1
mysql> select RELEASE_LOCK("lock1");
        -> NULL


    Note that the second RELEASE_LOCK() call returns NULL 
    because the lock "lock1" was automatically released by the second 
    GET_LOCK() call.  
  
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 wasn't locked by this thread (in which case the 
    lock is not released), and NULL if the named lock didn't exist. 
    The lock will not exist if it was never obtained by a call to GET_LOCK() 
    or if it already has been released.  
  
BENCHMARK(count,expr) 
  
 The BENCHMARK() function executes the expression expr 
    repeatedly count times. It may be used to time how fast MySQL 
    processes the expression. The result value is always 0. The intended 
    use is in the mysql client, which reports query execution times: 
    
mysql> select BENCHMARK(1000000,encode("hello","goodbye"));
+----------------------------------------------+
| BENCHMARK(1000000,encode("hello","goodbye")) |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
1 row in set (4.74 sec)


    The time reported is elapsed time on the client end, not CPU time on the server 
    end. It may be advisable to execute BENCHMARK() several times, 
    and interpret the result with regard to how heavily loaded the server machine 
    is.  
  
INET_NTOA(expr) 
  
 Returns the network address (4 or 8 byte) for the numeric expression: 
    
mysql> select INET_NTOA(3520061480);
       ->  "209.207.224.40"


     
  
INET_ATON(expr) 
  
 Returns an integer that represents the numeric value for a network address. 
    Addresses may be 4 or 8 byte addresses: 
    
mysql> select INET_ATON("209.207.224.40");
       ->  3520061480


    The generated number is always in network byte order; For example the above 
    number is calculated as 209*255^3 + 207*255^2 + 224*255 +40. 
     
  
MASTER_POS_WAIT(log_name, log_pos) 
  
 Blocks until the slave reaches the specified position in the master log 
    during replication. If master information is not initialized, returns NULL. 
    If the slave is not running, will block and wait until it is started and goes 
    to or past the specified position. If the slave is already past the specified 
    position, returns immediately. The return value is the number of log events 
    it had to wait to get to the specified position, or NULL in case of error. 
    Useful for control of master-slave synchronization, but was originally written 
    to facilitate replication testing. 
  
 





  
 
     Weiter Möglichkeiten 
      mit der DB zu arbeiten (rechnen, sortieren limitieren) 
    Aufgabe: Rechnen 
      mit der DB Sortieren der Ergebnisse

      Limitieren der Treffer Ersetzen von Zeichenfolgen Umwandeln von DS 		
  




 

   

    
 

        

        ©
          2001 by  tbee
           /  Impressum 
       last update at: 04.06. 2002 13:06:55 
    

    

     
       url: www.tbee.de/mysql/t4_funktionen2.php