Bienvenido



Haz ingresado al Blog de los alumnos del 4to semestre de Ingenieria Informatica de la Universidad Tecnológica de chile INACAP.


miércoles, 21 de noviembre de 2007

SELECT CON FUNCIONES DE FECHA

SELECT con Funciones de Fechas en Base de Datos MySQL
Creado por en

5 comentarios:

Nacho Coyhaique dijo...

WEEK()

WEEK(date [,mode])

Esta función devuelve el número de la semana para una fecha. El formato con dos argumentos permite especificar si la semana empieza en domingo o en lunes y si el valor de retorno debe estar en el rango 0-53 o 1-52. Cuando se omite el argumento de modo el valor por defecto usado es el de la variable del servidor default_week_format (o 0 en MySQL 4.0 o anterior). La tabla siguiente demuestra cómo trabaja el argumento mode:
Valor Significado
0 La semana empieza en domingo; devuelve un valor en el rango 0 a 53; la semana 1 es la primera semana que empieza en este año
1 La semana empieza en lunes; devuelve un valor en el rango 0 a 53; la semana 1 es la primera semana que tiene más de 3 días en este año
2 La semana empieza en domingo; devuelve un valor en el rango 1 a 53; la semana 1 es la primera semana que empieza en este año
3 La semana empieza en lunes; devuelve un valor en el rango 1 a 53; la semana 1 es la primera semana que tenga más de tres días en este año
4 La semana empieza en domingo; devuelve un valor en el rango 0 a 53; la semana 1 es la primera semana que tenga más de tres días en este año
5 La semana empieza en lunes; devuelve un valor en el rango 0 a 53; la semana 1 es la primera semana que empiece en este año
6 La semana empieza en domingo; devuelve un valor en el rango 1 a 53; la semana 1 es la primera semana que tenga más de tres días en este año
7 La semana empieza en lunes; devuelve un valor en el rango 1 a 53; la semana 1 es la primera semana que empiece en este este año

El valor de modo 3 puede usarse desde MySQL 4.0.5. El valor de modo 4 y superiores pueden usarse desde MySQL 4.0.17.

mysql> SELECT WEEK('1998-02-20');
+--------------------+
| WEEK('1998-02-20') |
+--------------------+
| 7 |
+--------------------+
1 row in set (0.00 sec)

mysql> SELECT WEEK('1998-02-20',0);
+----------------------+
| WEEK('1998-02-20',0) |
+----------------------+
| 7 |
+----------------------+
1 row in set (0.00 sec)

mysql> SELECT WEEK('1998-02-20',1);
+----------------------+
| WEEK('1998-02-20',1) |
+----------------------+
| 8 |
+----------------------+
1 row in set (0.00 sec)

mysql> SELECT WEEK('1998-12-31',1);
+----------------------+
| WEEK('1998-12-31',1) |
+----------------------+
| 53 |
+----------------------+
1 row in set (0.00 sec)

Nota: en la versión 4.0, WEEK(date,0) se modificó para que coincidiera con el calendario en USA. Antes de eso, WEEK() calculaba de forma incorrecta para fechas en USA. (En efecto, WEEK(date) y WEEK(date,0) era inorrecto en todos los casos.) So una fecha cae en la última semana del año anterior, MySQL retornará 0 si no se usa 2, 3, 6 o 7 como valor del argumento opcional mode:

mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
+--------------------+----------------------+
| YEAR('2000-01-01') | WEEK('2000-01-01',0) |
+--------------------+----------------------+
| 2000 | 0 |
+--------------------+----------------------+
1 row in set (0.00 sec)

Se puede argumentar que MySQL debe devolver 52 en la función WEEK(), porque la fecha dada está en la semana 53 de 1999. Pero se ha decidido devolver 0 en su lugar ya que se prefiere que la función devuelva "el número de la semana en el año dado". Esto hace el uso de la función WEEK() function más fiable cuando se combina con otras funciones que extraen una parte de la fecha. Si se prefiere que el resultado sea evaluado con respecto al año que contiene el primer día de la semana para la fecha dada, se debe usar 2, 3, 6 ó 7 en el argumento mode.

mysql> SELECT WEEK('2000-01-01',2);
+----------------------+
| WEEK('2000-01-01',2) |
+----------------------+
| 52 |
+----------------------+
1 row in set (0.00 sec)

Alternativamente, se puede usar la función YEARWEEK():

mysql> SELECT YEARWEEK('2000-01-01');
+------------------------+
| YEARWEEK('2000-01-01') |
+------------------------+
| 199952 |
+------------------------+
1 row in set (0.00 sec)

mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);
+---------------------------------+
| MID(YEARWEEK('2000-01-01'),5,2) |
+---------------------------------+
| 52 |
+---------------------------------+
1 row in set (0.00 sec)




Manuel Salazar
fuente: http://www.conclase.net/c/mysql/index.php?fun=WEEK

21 de noviembre de 2007 a las 22:38
Nacho Coyhaique dijo...

Cálculos con fechas

MySQL proporciona diversas funciones que se pueden usar para efectuar cálculos sobre fechas, por ejemplo, para calcular edades o extraer partes de una fecha (día, mes, año, etc).

Para determinar la edad de cada una de nuestras mascotas, tenemos que calcular la diferencia de años de la fecha actual y la fecha de nacimiento, y entonces substraer uno si la fecha actual ocurre antes en el calendario que la fecha de nacimiento. Las siguientes consultas muestran la fecha actual, la fecha de nacimiento y la edad para cada mascota.

mysql> SELECT nombre, nacimiento, CURRENT_DATE,
-> (YEAR(CURRENT_DATE) - YEAR(nacimiento))
-> - (RIGHT(CURRENT_DATE,5) <>

Dado que la expresión en sí es bastante fea, se ha usado un alias (edad) que es el que aparece como etiqueta en la columna que muestra el resultado de la consulta.

Esta consulta debe trabajar bien, pero el resultado puede ser de alguna manera más útil si las filas son presentadas en algún orden. Para ello haremos uso de la cláusula ORDER BY.

Por ejemplo, para ordenar por nombre, usaremos la siguiente consulta:

mysql> SELECT nombre, nacimiento, CURRENT_DATE,
-> (YEAR(CURRENT_DATE) - YEAR(nacimiento))
-> - (RIGHT(CURRENT_DATE,5) <> AS edad FROM mascotas ORDER BY nombre;
+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | edad |
+--------+------------+--------------+------+
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
+--------+------------+--------------+------+
9 rows in set (0.00 sec)Para ordenar por edad en lugar de nombre, únicamente tenemos que usar una cláusula ORDER BY diferente:

mysql> SELECT nombre, nacimiento, CURRENT_DATE,
-> (YEAR(CURRENT_DATE) - YEAR(nacimiento))
-> - (RIGHT(CURRENT_DATE,5) <> AS edad FROM mascotas ORDER BY edad;
+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | edad |
+--------+------------+--------------+------+
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |
+--------+------------+--------------+------+
9 rows in set (0.01 sec)Una consulta similar puede ser usada para determinar la edad que tenía una mascota cuando falleció. Para determinar que animalitos ya fallecieron, la condición es que el valor en el campo fallecimiento no sea nulo (NULL). Entonces, para los registros con valor no-nulo, calculamos la diferencia entre los valores fallecimiento y nacimiento.

mysql> SELECT nombre, nacimiento, fallecimiento,
-> (YEAR(fallecimiento) - YEAR(nacimiento))
-> - (RIGHT(fallecimiento,5) <> AS edad FROM mascotas WHERE fallecimiento IS NOT NULL;
+--------+------------+---------------+------+
| nombre | nacimiento | fallecimiento | edad |
+--------+------------+---------------+------+
| Kaiser | 1989-08-31 | 1997-07-29 | 7 |
+--------+------------+---------------+------+
1 row in set (0.01 sec)La consulta usa fallecimiento IS NOT NULL, en vez de falleciimiento < > NULL porque NULL es una valor especial. Esto será explicando más a detalle posteriormente.

¿Qué sucede si deseamos conocer cuáles de nuestras mascotas cumplen años el próximo mes? Para este tipo de cálculos, el año y el día son irrelevantes; simplemente tenemos que extraer el valor del mes en la columna nacimiento. Como se mencionó anteriormente, MySQL proporciona diversas funciones para trabajar y manipular fechas, en este caso haremos uso de la función MONTH( ). Para ver como trabaja, vamos a ejecutar una consulta muy simple que muestra tanto el valor de una fecha como el valor que regresa la función MONTH( ).

mysql> SELECT nombre, nacimiento, MONTH(nacimiento) FROM mascotas;
+--------+------------+-------------------+
| nombre | nacimiento | MONTH(nacimiento) |
+--------+------------+-------------------+
| Fluffy | 1999-02-04 | 2 |
| Mau | 1998-03-17 | 3 |
| Buffy | 1999-05-13 | 5 |
| FanFan | 2000-08-27 | 8 |
| Kaiser | 1989-08-31 | 8 |
| Chispa | 1998-09-11 | 9 |
| Wicho | 2000-02-09 | 2 |
| Skim | 2001-04-29 | 4 |
| Pelusa | 2000-03-30 | 3 |
+--------+------------+-------------------+
9 rows in set (0.00 sec)Encontrar los animalitos cuyo cumpleaños es el próximo mes es muy sencillo. Suponiendo que el mes actual es Abril (valor 4), entonces tenemos que buscar los registros cuyo valor de mes sea 5 (Mayo).

mysql> SELECT nombre, nacimiento FROM mascotas WHERE MONTH(nacimiento) = 5;
+--------+------------+
| nombre | nacimiento |
+--------+------------+
| Buffy | 1999-05-13 |
+--------+------------+
1 row in set (0.00 sec)Aquí habrá por supuesto una complicación si el mes actual es Diciembre. No podemos simplemente agregar uno al número del mes (12) y buscar los registros cuyo mes de nacimiento sea 13 porque dicho mes no existe. En vez de esto, tenemos que buscar los animalitos que nacieron en Enero (mes 1).

Sin embargo, lo mejor es que podemos escribir una consulta que funcione no importando cuál sea el mes actual. La función DATE_ADD( ) nos permite agregar un intervalo de tiempo a una fecha dada. Si agregamos un mes al valor regresado por la función NOW( ), y entonces extraemos el valor del mes con la función MONTH( ), el resultado es que siempre obtendremos el mes siguiente.

La consulta que resuelve nuestro problema queda así:

mysql> SELECT nombre, nacimiento FROM mascotas
-> WHERE MONTH(nacimiento) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH));

Manuel Salazar

21 de noviembre de 2007 a las 22:40
Nacho Coyhaique dijo...

Consultas a BD con fechas
Lo que intentaremos ahora es que la consulta a la BD nos devuelva ya los 4 valores necesarios (fecha de inicio, fecha actual, fecha de finalizacion y dias restantes) con sus formatos. El periodo de 90 dias lo declararemos directamente en la consulta:
" SELECT username, DATE_FORMAT(subscript_date,'%d/%m/%Y') AS fecha_subscrip,
DATE_FORMAT(CURDATE(),'%d/%m/%Y') AS hoy,
DATE_FORMAT(ADDDATE(subscript_date, INTERVAL 90 DAY),'%d/%m/%Y') AS fecha_final,
TO_DAYS(ADDDATE(subscript_date, INTERVAL 90 DAY))-TO_DAYS(CURDATE()) AS dias_restantes
FROM tbl_users WHERE username='session_param' "
Con esta consulta hemos conseguido los 4 valores con formato (incluída la fecha actual), recuperables en DW (Recordset ‘RSusers’) como:
$row_RSusers['fecha_suscrip'];
$row_RSusers['hoy'];
$row_RSusers['fecha_final'];
$row_RSusers['dias_restantes'];

Veamos las funciones utilizadas:
DATE_FORMAT(fecha,formato):El primer parametro se corresponde con la columna de la BD que almacena la fecha (o con una fecha declarada directamente) y la segunda con el formato a aplicar.
¿ Como se define el formato? mediante el uso del símbolo '%' seguido de una letra que define el formato. Nosotros hemos utilizado:
%Y: devuelve el año en formato largo (2002);
%m: devuelve el mes en formato de dos cifras (01/12);
%m: devuelve el día en formato de dos cifras (01/31);
Puedes encontrar el listado completo en:
http://dev.mysql.com/doc/mysql/en/Date_and_time_functions.html
Dentro de formato se puede añadir texto o caracteres para enriquecerlo. Por ejemplo:
DATE_FORMAT(subscript_date,'%d/%m/%Y') : devuelve 25/10/2002
DATE_FORMAT(subscript_date,'%d-%m-%Y') : devuelve 25-10-2002
DATE_FORMAT(subscript_date,'%d del %m de %Y') : devuelve 25 del10 de 2002.

CURDATE(): devuelve la fecha actual en formato "aaaa-mm-dd", sin embargo, MySQL es capaz de darle formato sin realizar nada especial.

ADDDATE(fecha INTERVAL tiempo): añade 'tiempo' a 'fecha'. En nuestra consulta añadimos 90 días a la fecha actual, por lo que declaramos:
ADDDATE(CURDATE(), INTERVAL 90 DAY)
El parametro "tiempo" admite varias posibilidades de declaración, como por ejemplo:
ADDDATE('2002-08-21', INTERVAL 9 MONTH): Añade 9 meses a la fecha.
ADDDATE('2002-08-21', INTERVAL 1-3 YEAR_MONTH): Añade 1 año y 3 meses a la fecha.

TO_DAYS(fecha): devuelve el numero de días desde el 1 de enero del año 0, lo que nos es útil para poder operar con días completos y luego dar formato. Así, la linea:
TO_DAYS(ADDDATE(subscript_date, INTERVAL 90 DAY))-TO_DAYS(CURDATE()) AS dias_restantes
Calcula primero el numero de días para la fecha de expiración (ADDDATE(subscript_date, INTERVAL 90 DAY)), lo convierte a días mediante TO_DAYS y luego los resta al número de días para la fecha actual (TO_DAYS(CURDATE()))

Nota: MySQL 4.1.1 añade la función DATEDIFF(fecha1,fecha2), que devuelve el número de días entre la fecha1 y la fecha 2. Para el tutorial he decidido no emplearla por considerar que muchos usuarios aún utilizan versiones anteriores de MySQL. En la linea anterior podríamos haber escrito:
DATEDIFF(ADDDATE(subscript_date, INTERVAL 90 DAY), CURDATE())
Existe un listado completo de éstas en la URL:
http://www.mysql.com/doc/en/Date_and_time_functions.html

Un pequeño comentario antes de seguir: Algunos expertos afirman que este método (dar formato directamente en la consulta) mejora el rendimiento, ya que aprovecha la velocidad de MySQL. Si compensa o no utilizarlo es decisión de cada uno.
Manuel Salazar

21 de noviembre de 2007 a las 22:40
Nacho Coyhaique dijo...

DATE_ADD()
DATE_SUB()

DATE_ADD(date,INTERVAL expr type)
DATE_SUB(date,INTERVAL expr type)

Estas funciones realizan aritmética con fechas. Desde MySQL 3.23, INTERVAL expr type se permite en cualquiera de los lados del operador + si la expresión en el otro lado es un valor de tipo date o datetime. Para el operador -, INTERVAL expr type se permite sólo en el lado derecho, porque no tiene sentido restar un valor de tipo date o datetime desde un intervalo. (Ver ejemplos.) date es un valor de tipo DATETIME o DATE que especifica la fecha de comienzo. expr es una expresión que especifica un valor de intervalo a añadir o restar desde la fecha de comienzo. expr es una cadena; puede empezar con un '-' para intervalos negativos. type es una palabra clave que indica cómo debe interpretarse la expresión. La tabla siguiente muestra cómo se relacionan los argumentos type y expr:
Valor type Formato de expr esperado
MICROSECOND MICROSECONDS
SECOND SECONDS
MINUTE MINUTES
HOUR HOURS
DAY DAYS
WEEK WEEKS
MONTH MONTHS
QUARTER QUARTERS
YEAR YEARS
SECOND_MICROSECOND 'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND 'MINUTES.MICROSECONDS'
MINUTE_SECOND 'MINUTES:SECONDS'
HOUR_MICROSECOND 'HOURS.MICROSECONDS'
HOUR_SECOND 'HOURS:MINUTES:SECONDS'
HOUR_MINUTE 'HOURS:MINUTES'
DAY_MICROSECOND 'DAYS.MICROSECONDS'
DAY_SECOND 'DAYS HOURS:MINUTES:SECONDS'
DAY_MINUTE 'DAYS HOURS:MINUTES'
DAY_HOUR 'DAYS HOURS'
YEAR_MONTH 'YEARS-MONTHS'

Los valores de tipo DAY_MICROSECOND, HOUR_MICROSECOND, MINUTE_MICROSECOND, SECOND_MICROSECOND, and MICROSECOND están permitidos desde MySQL 4.1.1. Los valores QUARTER y WEEK están permitidos desd MySQL 5.0.0. MySQL permite cualquier delimitador de puntuación en el formato de expr. Los mostrados en la tabla son los delimitadores propuestos. Si el argumento date es un valor DATE y los cáculos involucran sólo las partes de YEAR, MONTH y DAY (es decir, no las partes de hora), el resultado es un valor DATE. En otro caso, el resultado en un valor DATETIME:

mysql> SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND;
+-------------------------------------------+
| '1997-12-31 23:59:59' + INTERVAL 1 SECOND |
+-------------------------------------------+
| 1998-01-01 00:00:00 |
+-------------------------------------------+
1 row in set (0.02 sec)

mysql> SELECT INTERVAL 1 DAY + '1997-12-31';
+-------------------------------+
| INTERVAL 1 DAY + '1997-12-31' |
+-------------------------------+
| 1998-01-01 |
+-------------------------------+
1 row in set (0.00 sec)

mysql> SELECT '1998-01-01' - INTERVAL 1 SECOND;
+----------------------------------+
| '1998-01-01' - INTERVAL 1 SECOND |
+----------------------------------+
| 1997-12-31 23:59:59 |
+----------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL 1 SECOND);
+----------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL 1 SECOND) |
+----------------------------------------------------+
| 1998-01-01 00:00:00 |
+----------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL 1 DAY);
+-------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL 1 DAY) |
+-------------------------------------------------+
| 1998-01-01 23:59:59 |
+-------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL '1:1' MINUTE_SECOND) |
+---------------------------------------------------------------+
| 1998-01-01 00:01:00 |
+---------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_SUB('1998-01-01 00:00:00',
-> INTERVAL '1 1:1:1' DAY_SECOND);
+----------------------------------------------------------------+
| DATE_SUB('1998-01-01 00:00:00', INTERVAL '1 1:1:1' DAY_SECOND) |
+----------------------------------------------------------------+
| 1997-12-30 22:58:59 |
+----------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1998-01-01 00:00:00',
-> INTERVAL '-1 10' DAY_HOUR);
+------------------------------------------------------------+
| DATE_ADD('1998-01-01 00:00:00', INTERVAL '-1 10' DAY_HOUR) |
+------------------------------------------------------------+
| 1997-12-30 14:00:00 |
+------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+-----------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY) |
+-----------------------------------------+
| 1997-12-02 |
+-----------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
-> INTERVAL '1.999999' SECOND_MICROSECOND);
-> '1993-01-01 00:00:01.000001'

Si se especifica un valor de intervalo demasiado corto (que no incluye todas las partes del intervalo que se esperan dada la palabra clace en tipo), MySQL asume que se han perdido las partes de la izquierda del valor de intervalo. Por ejemplo, si se especifica un tipo DAY_SECOND, se espera que el valor de expr contenga las partes correspondientes a días, horas, minutos y segundos. Si se especifica un valor como '1:10', MySQL asume que las partes de días y horas se han perdido y el valor representa minutos y segundos. En otras palabras, '1:10' DAY_SECOND se interpreta del mismo modo que si se hubiese usado '1:10' MINUTE_SECOND. Esto es análogo al modo en que MySQL interpreta valores TIME que representan intervalos de tiempo en lugar de tiempo con respecto al día. Si se suma o resta desde un valor de fecha algo que contiene la parte de la hora, el resultado se convierte automáticamente a un valor de fecha y hora:

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'

Se se usan fechas mal formadas, el resultado es NULL. Si se suma MONTH, YEAR_MONTH o YEAR y la fecha resultado contiene un día que es mayor que el máximo para el nuevo mes, el día se ajusta al máximo para el mes nuevo:

mysql> SELECT DATE_ADD('1998-01-30', interval 1 month);
-> '1998-02-28'

Notar que para el ejemplo anterior la palabra clave INTERVAL y el especificador de tipo no son case-sensitive.


Manuel Salazar

fuente : http://mysql.conclase.net/curso/index.php?fun=DATE_ADD

21 de noviembre de 2007 a las 22:41
Nacho Coyhaique dijo...

Funciones de fecha y hora

Esta sección describe las funciones que pueden usarse para manipular valores temporales. Consulte Sección 11.3, “Tipos de fecha y hora” para una descripción del rango de los valores que tiene cada fecha y hora y los formatos válidos en que se puedene especificar los valores.

Aquí hay un ejemplo que usa funciones de fecha. La siguiente consulta selecciona todos los registros con un valor date_col dentro de los últimos 30 días:

mysql> SELECT something FROM tbl_name
-> WHERE DATE_SUB(CURDATE(),INTERVAL 30 DAY) <= date_col;

Tenga en cuenta que la consulta también selecciona registros con fechas futuras.

Las funciones que esperan valores de fecha usualmente aceptan valores de fecha y hora e ignoran la parte de hora. Las funciones que esperan valores de hora usualmente aceptan valores de fecha y hora e ignoran la parte de fecha.

Las funciones que retornan la fecha u hora actuales se evalúan sólo una vez por consulta al principio de la ejecución de consulta. Esto significa que las referencias múltiples a una función tales como NOW() en una misma consulta siempre producen el mismo resultado. Este principio también se aplica a CURDATE(), CURTIME(), UTC_DATE(), UTC_TIME(), UTC_TIMESTAMP(), y a cualquiera de sus sinónimos.

En MySQL 5.0, las funciones CURRENT_TIMESTAMP(), CURRENT_TIME(), CURRENT_DATE(), y FROM_UNIXTIME() retornan valores en la zona horaria de la conexión, que está disponible como valor de la variable de sistema time_zone . Además, UNIX_TIMESTAMP() asume que su argumento es un valor de fecha y hora en la zona horaria actual. Consulte Sección 5.9.8, “Soporte de zonas horarias en el servidor MySQL”.

Los rango de retorno en las siguientes descripciones de funciones se aplican en fechas completas. Si la fecha es un valor “cero” o una fecha incompleta como '2001-11-00', las funciones que extraen una parte de la fecha pueden retornar 0. Por ejemplo DAYOFMONTH('2001-11-00') retorna 0.

*

ADDDATE(date,INTERVAL expr type), ADDDATE(expr,days)

Cuando se invoca con la forma INTERVAL del segundo argumento, ADDDATE() es sinónimo de DATE_ADD(). La función relacionada SUBDATE() es sinónimo de DATE_SUB(). Para información del argumento INTERVAL , consulte la discusión de DATE_ADD().

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
-> '1998-02-02'
mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
-> '1998-02-02'

Si el argumento days es simplemente un valor entero, entonces MySQL 5.0 lo trata como el número de días a añadir a expr.

mysql> SELECT ADDDATE('1998-01-02', 31);
-> '1998-02-02'

*

ADDTIME(expr,expr2)

ADDTIME() añade expr2 a expr y retorna el resultado. expr es una expresión de fecha u hora y fecha, y expr2 es una expresión temporal.

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999',
-> '1 1:1:1.000002');
-> '1998-01-02 01:01:01.000001'
mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');
-> '03:00:01.999997'

*

CONVERT_TZ(dt,from_tz,to_tz)

CONVERT_TZ() convierte un valor datetime dt de la zona horaria dada por from_tz a la zona horaria dada por to_tz y retorna el valor resultante. Las zonas horarias pueden especificarse como se describe en Sección 5.9.8, “Soporte de zonas horarias en el servidor MySQL”. Esta función retorna NULL si los argumentos son inválidos.

Si el valor se sale del rango soportado por el tipo TIMESTAMP al convertirse de from_tz a UTC, no se realiza ninguna conversión. El rango TIMESTAMP se describe en Sección 11.1.2, “Panorámica de tipos de fechas y hora”.

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
-> '2004-01-01 13:00:00'
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
-> '2004-01-01 22:00:00'

Nota: Para usar zonas horarias con nombres tales como 'MET' o 'Europe/Moscow', las tabas de zona horaria deben estar actualizadas correctamente. Consulte Sección 5.9.8, “Soporte de zonas horarias en el servidor MySQL” para instrucciones.

*

CURDATE()

Retorna la fecha horaria como valor en formato 'YYYY-MM-DD' o YYYYMMDD, dependiendo de si la fucnión se usa en un contexto numérico o de cadena de caracteres.

mysql> SELECT CURDATE();
-> '1997-12-15'
mysql> SELECT CURDATE() + 0;
-> 19971215

*

CURRENT_DATE, CURRENT_DATE()

CURRENT_DATE y CURRENT_DATE() son sinónimos de CURDATE().

*

CURTIME()

Retorna la hora actual como valor en formato 'HH:MM:SS' o HHMMSS dependiendo de si la fucnión se usa en un contexto numérico o de cadena de caracteres.

mysql> SELECT CURTIME();
-> '23:50:26'
mysql> SELECT CURTIME() + 0;
-> 235026

*

CURRENT_TIME, CURRENT_TIME()

CURRENT_TIME y CURRENT_TIME() son sinónimos de CURTIME().

*

CURRENT_TIMESTAMP, CURRENT_TIMESTAMP()

CURRENT_TIMESTAMP() son sinónimos de NOW().

*

DATE(expr)

Extrae la parte de fecha de la expresión de fecha o fecha y hora expr.

mysql> SELECT DATE('2003-12-31 01:02:03');
-> '2003-12-31'

*

DATEDIFF(expr,expr2)

DATEDIFF() retorna el número de días entre la fecha inicial expr y la fecha final expr2. expr y expr2 son expresiones de fecha o de fecha y hora. Sólo las partes de fecha de los valores se usan en los cálculos.

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
-> 1
mysql> SELECT DATEDIFF('1997-11-30 23:59:59','1997-12-31');
-> -31

*

DATE_ADD(date,INTERVAL expr type), DATE_SUB(date,INTERVAL expr type)

Estas funciones realizan operaciones aritméticas de fechas. date es un valor DATETIME o DATE especificando la fecha de inicio. expr es una expresión que especifica el intervalo a añadir o borrar de la fecha de inicio. expr es una cadena; puede comenzar con un '-' para intervalos negativos. type es una palabra clave que indica cómo debe interpretarse la expresión.

La palabra clave INTERVAL y el especificador type no son sensibles a mayúsculas.

La siguiente tabla muestra cómo se relacionan los argumentos type y expr :
type Value Expected expr Format
MICROSECOND MICROSECONDS
SECOND SECONDS
MINUTE MINUTES
HOUR HOURS
DAY DAYS
WEEK WEEKS
MONTH MONTHS
QUARTER QUARTERS
YEAR YEARS
SECOND_MICROSECOND 'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND 'MINUTES.MICROSECONDS'
MINUTE_SECOND 'MINUTES:SECONDS'
HOUR_MICROSECOND 'HOURS.MICROSECONDS'
HOUR_SECOND 'HOURS:MINUTES:SECONDS'
HOUR_MINUTE 'HOURS:MINUTES'
DAY_MICROSECOND 'DAYS.MICROSECONDS'
DAY_SECOND 'DAYS HOURS:MINUTES:SECONDS'
DAY_MINUTE 'DAYS HOURS:MINUTES'
DAY_HOUR 'DAYS HOURS'
YEAR_MONTH 'YEARS-MONTHS'

Los valores QUARTER y WEEK están disponibles a partir de MySQL 5.0.0.

MySQL permite cualquier delimitador en el formato expr . Los mostrados en la tabla son sugerencias. Si el argumento date es un valora DATE y sus cálculos involucarán sólo partes YEAR, MONTH, y DAY (esto es, sin partes de hora), el resultado es un valor DATE . De otro modo, el resultado es un valor DATETIME .

INTERVAL expr type se permite en cualquier lado del operador + si la expresión en el otro lado es una fecha o fecha y hora. Para el operador - , INTERVAL expr type se permite sólo en la parte derecha, ya que no tiene sentido restar una fecha de un intervalo. (Consulte los ejemplos a continuación.)

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'
mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
-> INTERVAL '1.999999' SECOND_MICROSECOND);
-> '1993-01-01 00:00:01.000001'

Si especifica un intervalo demasiado pequeño (no incluye todas las partes de intervalo que se esperarían de la palabra clave type ), MySQL asume que ha dejado la parte más a la izquierda del valor del intervalo. Por ejemplo, si especifica un type de DAY_SECOND, se espera que el valor de expr tenga días, horas, minutos y segundos. Si especifica un valor como '1:10', MySQL asume que las partes de día y hora no se encuentran disponibles y que el valor representa minutos y segundos. En otras palabras, '1:10' DAY_SECOND se interpreta de forma que es equivalente a '1:10' MINUTE_SECOND. Esto es análogo a la forma en que MySQL interpreta valores TIME como representando tiempo transcurrido en lugar de la hora del día.

Si suma o borra de un valor de fecha algo que contenga una parte de fora, el resultado se convierte automáticamente a valor fecha/hora:

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'

Si usa fechas muy mal formadas, el resultado es NULL. Si suma MONTH, YEAR_MONTH, o YEAR y la fecha resultante tiene un día mayor que el día máximo para el nuevo mes, el día se ajusta al número máximo del nuevo mes:

mysql> SELECT DATE_ADD('1998-01-30', INTERVAL 1 MONTH);
-> '1998-02-28'

*

DATE_FORMAT(date,format)

Formatea el valor date según la cadena format . Los siguientes especificadores pueden usarse en la cadena format :
Especificador Descripción
%a Día de semana abreviado (Sun..Sat)
%b Mes abreviado (Jan..Dec)
%c Mes, numérico (0..12)
%D Día del mes con sufijo inglés (0th, 1st, 2nd, 3rd, ...)
%d Día del mes numérico (00..31)
%e Día del mes numérico (0..31)
%f Microsegundos (000000..999999)
%H Hora (00..23)
%h Hora (01..12)
%I Hora (01..12)
%i Minutos, numérico (00..59)
%j Día del año (001..366)
%k Hora (0..23)
%l Hora (1..12)
%M Nombre mes (January..December)
%m Mes, numérico (00..12)
%p AM o PM
%r Hora, 12 horas (hh:mm:ss seguido de AM o PM)
%S Segundos (00..59)
%s Segundos (00..59)
%T Hora, 24 horas (hh:mm:ss)
%U Semana (00..53), donde domingo es el primer día de la semana
%u Semana (00..53), donde lunes es el primer día de la semana
%V Semana (01..53), donde domingo es el primer día de la semana; usado con %X
%v Semana (01..53), donde lunes es el primer día de la semana; usado con %x
%W Nombre día semana (Sunday..Saturday)
%w Día de la semana (0=Sunday..6=Saturday)
%X Año para la semana donde domingo es el primer día de la semana, numérico, cuatro dígitos; usado con %V
%x Año para la semana, donde lunes es el primer día de la semana, numérico, cuatro dígitos; usado con %v
%Y Año, numérico, cuatro dígitos
%y Año, numérico (dos dígitos)
%% Carácter '%' literal

Todos los otros caracteres se copian al resultado sin interpretación.

Tenga en cuenta que el carácter '%' se necesita antes de caracteres especificadores de formato.

Los rangos para los especificadores de mes y día comienzan en cero debido a que MySQL permite almacenar fechas incompletas tales como '2004-00-00'.

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'

*

DAY(date)

DAY() es sinónimo de DAYOFMONTH().

*

DAYNAME(date)

Retorna el nombre del día de la semana para date.

mysql> SELECT DAYNAME('1998-02-05');
-> 'Thursday'

*

DAYOFMONTH(date)

Retorna el día del mes para date, en el rango 1 a 31.

mysql> SELECT DAYOFMONTH('1998-02-03');
-> 3

*

DAYOFWEEK(date)

Retorna el índice del día de la semana para date (1 = lunes, 2 = martes, ..., 7 = sábado). Estos valores del índice se corresponden con el estándar ODBC.

mysql> SELECT DAYOFWEEK('1998-02-03');
-> 3

*

DAYOFYEAR(date)

Retorna el día del año para date, en el rango 1 a 366.

mysql> SELECT DAYOFYEAR('1998-02-03');
-> 34

*

EXTRACT(type FROM date)

La función EXTRACT() usa la misma clase de especificadores de tipo que DATE_ADD() o DATE_SUB(), pero extrae partes de la fecha en lugar de realizar aritmética de fecha.

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
mysql> SELECT EXTRACT(MICROSECOND
-> FROM '2003-01-02 10:30:00.000123');
-> 123

*

FROM_DAYS(N)

Dado un número de día N, retorna un valor DATE .

mysql> SELECT FROM_DAYS(729669);
-> '1997-10-07'

Use FROM_DAYS() con precaución en fechas viejas. No se pretende que se use con valores que precedan el calendario Gregoriano (1582). Consulte Sección 12.6, “Qué calendario utiliza MySQL”.

*

FROM_UNIXTIME(unix_timestamp) , FROM_UNIXTIME(unix_timestamp,format)

Retorna una representación del argumento unix_timestamp como un valor en formato 'YYYY-MM-DD HH:MM:SS' o YYYYMMDDHHMMSS , dependiendo de si la función se usa en un formato numérico o de cadena de caracteres.

mysql> SELECT FROM_UNIXTIME(875996580);
-> '1997-10-04 22:23:00'
mysql> SELECT FROM_UNIXTIME(875996580) + 0;
-> 19971004222300

Si se da format, el resultado se formatea según la cadena format. format puede contener los mismos especificadores que los listados en la entrada para la función DATE_FORMAT() .

mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
-> '%Y %D %M %h:%i:%s %x');
-> '2003 6th August 06:22:58 2003'

*

GET_FORMAT(DATE|TIME|DATETIME, 'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL')

Retorna una cadena de formato. Esta función es útil en combinación con las funciones DATE_FORMAT() y STR_TO_DATE() .

Los tres valores posibles para el primer argumento y los cinco posibles valores para el segundo argumento resultan en 15 posibles cadenas de formato (para los especificadores usados, consulte la tabla en la descripción de la función DATE_FORMAT() ).
LLamad a función Resultado
GET_FORMAT(DATE,'USA') '%m.%d.%Y'
GET_FORMAT(DATE,'JIS') '%Y-%m-%d'
GET_FORMAT(DATE,'ISO') '%Y-%m-%d'
GET_FORMAT(DATE,'EUR') '%d.%m.%Y'
GET_FORMAT(DATE,'INTERNAL') '%Y%m%d'
GET_FORMAT(DATETIME,'USA') '%Y-%m-%d-%H.%i.%s'
GET_FORMAT(DATETIME,'JIS') '%Y-%m-%d %H:%i:%s'
GET_FORMAT(DATETIME,'ISO') '%Y-%m-%d %H:%i:%s'
GET_FORMAT(DATETIME,'EUR') '%Y-%m-%d-%H.%i.%s'
GET_FORMAT(DATETIME,'INTERNAL') '%Y%m%d%H%i%s'
GET_FORMAT(TIME,'USA') '%h:%i:%s %p'
GET_FORMAT(TIME,'JIS') '%H:%i:%s'
GET_FORMAT(TIME,'ISO') '%H:%i:%s'
GET_FORMAT(TIME,'EUR') '%H.%i.%S'
GET_FORMAT(TIME,'INTERNAL') '%H%i%s'

El formato ISO es ISO 9075, no ISO 8601.

En MySQL 5.0, TIMESTAMP puede usarse; GET_FORMAT() retorna los mismos valores que para DATETIME.

mysql> SELECT DATE_FORMAT('2003-10-03',GET_FORMAT(DATE,'EUR'));
-> '03.10.2003'
mysql> SELECT STR_TO_DATE('10.31.2003',GET_FORMAT(DATE,'USA'));
-> '2003-10-31'



Consulte Sección 13.5.3, “Sintaxis de SET”.

*

HOUR(time)

Retorna la hora para time. El rango del valor de retorno es 0 a 23 para valores de horas del día.

mysql> SELECT HOUR('10:05:03');
-> 10

Además, el rango de los valores TIME es mucho mayor, así que HOUR puede retornar valores mayores que 23.

mysql> SELECT HOUR('272:59:59');
-> 272

*

LAST_DAY(date)

Toma una fecha o fecha/hora y retorna el valor correspondiente para el último día del mes. Retorna NULL si el argumento es inválido.

mysql> SELECT LAST_DAY('2003-02-05');
-> '2003-02-28'
mysql> SELECT LAST_DAY('2004-02-05');
-> '2004-02-29'
mysql> SELECT LAST_DAY('2004-01-01 01:01:01');
-> '2004-01-31'
mysql> SELECT LAST_DAY('2003-03-32');
-> NULL

*

LOCALTIME, LOCALTIME()

LOCALTIME y LOCALTIME() son sinónimos de NOW().

*

LOCALTIMESTAMP, LOCALTIMESTAMP()

LOCALTIMESTAMP y LOCALTIMESTAMP() son sinónimos de NOW().

*

MAKEDATE(year,dayofyear)

Retorna una fecha, dado un año y día del año. dayofyear debe ser mayor a 0 o el resultado es NULL.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
-> '2001-01-31', '2001-02-01'
mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365);
-> '2001-12-31', '2004-12-30'
mysql> SELECT MAKEDATE(2001,0);
-> NULL

*

MAKETIME(hour,minute,second)

Retorna un valor horario calculado a partir de los argumentos hour, minute, y second .

mysql> SELECT MAKETIME(12,15,30);
-> '12:15:30'

*

MICROSECOND(expr)

Retorna los microsegundos a partir del a expresión de hora o fecha/hora expr como número en el rango de 0 a 999999.

mysql> SELECT MICROSECOND('12:00:00.123456');
-> 123456
mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010');
-> 10

*

MINUTE(time)

Retorna el minuto de time, en el rango 0 a 59.

mysql> SELECT MINUTE('98-02-03 10:05:03');
-> 5

*

MONTH(date)

Retorna el mes para date, en el rango 1 a 12.

mysql> SELECT MONTH('1998-02-03');
-> 2

*

MONTHNAME(date)

Retorna el nombre completo del mes para date.

mysql> SELECT MONTHNAME('1998-02-05');
-> 'February'

*

NOW()

Retorna la fecha y hora actual como valor en formato 'YYYY-MM-DD HH:MM:SS' o YYYYMMDDHHMMSS , dependiendo de si la función se usa en contexto numérico o de cadena de caracteres.

mysql> SELECT NOW();
-> '1997-12-15 23:50:26'
mysql> SELECT NOW() + 0;
-> 19971215235026

*

PERIOD_ADD(P,N)

Añade N meses al periodo P (en el formato YYMM o YYYYMM). Retorna un valor en el formato YYYYMM. Tenga en cuenta que el argumento del periodo P no es una fecha.

mysql> SELECT PERIOD_ADD(9801,2);
-> 199803

*

PERIOD_DIFF(P1,P2)

Retorna el número de meses entre periodos P1 y P2. P1 y P2 deben estar en el formato YYMM o YYYYMM. Tenga en cuenta que los argumentos del periodo P1 y P2 no son fechas.

mysql> SELECT PERIOD_DIFF(9802,199703);
-> 11

*

QUARTER(date)

Retorna el cuarto del año para date, en el rango 1 a 4.

mysql> SELECT QUARTER('98-04-01');
-> 2

*

SECOND(time)

Retorna el segundo para time, en el rango 0 a 59.

mysql> SELECT SECOND('10:05:03');
-> 3

*

SEC_TO_TIME(seconds)

Retorna el argumento seconds , convertido a horas, minutos y segundos, como un valor en formato 'HH:MM:SS' o HHMMSS, dependiendo de si la función se usa en contexto numérico o de cadena de caracteres.

mysql> SELECT SEC_TO_TIME(2378);
-> '00:39:38'
mysql> SELECT SEC_TO_TIME(2378) + 0;
-> 3938

*

STR_TO_DATE(str,format)
*

Esta es la inversa de la función DATE_FORMAT(). Toma la cadena str y la cadena de formato format. STR_TO_DATE() retorna un valor DATETIME si la cadena de formato contiene parte de fecha y hora, o un valor DATE o TIME si la cadena contiene sólo parte de fecha o hora.

Los valores fecha, hora o fecha/hora contenidos en str deben ser dados en el formato indicado por format. Para los especificadores que pueden usarse en format, consulte la tabla en la descripción de la función DATE_FORMAT() . Todos los otros caracteres no se interpretan. Si str contiene un valor fecha, hora o fecha/hora ilegal, STR_TO_DATE() retorna NULL. A partir de MySQL 5.0.3, un valor ilegal también produce una advertencia.


mysql> SELECT STR_TO_DATE('03.10.2003 09.20','%d.%m.%Y %H.%i');
-> '2003-10-03 09:20:00'
mysql> SELECT STR_TO_DATE('10arp', '%carp');
-> '0000-10-00 00:00:00'
mysql> SELECT STR_TO_DATE('2003-15-10 00:00:00','%Y-%m-%d %H:%i:%s');
-> NULL

El chequeo de rango en las partes de los valores de fecha se describe en Sección 11.3.1, “Los tipos de datos DATETIME, DATE y TIMESTAMP”. Esto significa, por ejemplo, que una fecha con una parte de día mayor que el número de días en un mes se permite mientras la parte del día esté en el rango de 1 a 31. También, fechas “cero” o fechas con partes de 0 se permiten.

mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
-> '0000-00-00'
mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
-> '2004-04-31'

*

SUBDATE(date,INTERVAL expr type), SUBDATE(expr,days)

Cuando se invoca con la forma INTERVAL del segundo argumento, SUBDATE() es sinónimo de DATE_SUB(). Para información del argumento INTERVAL , consulte la discusión para DATE_ADD().

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
-> '1997-12-02'
mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
-> '1997-12-02'

La siguiente forma permite el uso de un valor entero para days. En tales casos, es el número de días a ser borrados de la expresión fecha o fecha/hora expr.

mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31);
-> '1997-12-02 12:00:00'

Nota no puede usar formato "%X%V" para convertir una cadena año-semana en fecha ya que la combinación de un año y semana no identific unívocamente un año y semana si la semana atraviesa la forntera de un mes. Para convertir un año-semana a fecha, debe especificar el día de la semana:

mysql> select str_to_date('200442 Monday', '%X%V %W');
-> 2004-10-18

*

SUBTIME(expr,expr2)

SUBTIME() resta expr2 de expr y retorna el resultado. expr es una expresión de hora o fecha/hora, y expr2 es una expresión de hora.

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
-> '1997-12-30 22:58:58.999997'
mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');
-> '-00:59:59.999999'

*

SYSDATE()

SYSDATE() es sinónimo de NOW().

*

TIME(expr)

Extrae la parte de hora de la expresión hora o fecha/hora expr.

mysql> SELECT TIME('2003-12-31 01:02:03');
-> '01:02:03'
mysql> SELECT TIME('2003-12-31 01:02:03.000123');
-> '01:02:03.000123'

*

TIMEDIFF(expr,expr2)

TIMEDIFF() retorna el tiempo entre la hora de inicio expr y la hora final expr2. expr y expr2 son expresiones de hora o de fecha/hora, pero ambas deben ser del mismo tipo.

mysql> SELECT TIMEDIFF('2000:01:01 00:00:00',
-> '2000:01:01 00:00:00.000001');
-> '-00:00:00.000001'
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
-> '1997-12-30 01:01:01.000002');
-> '46:58:57.999999'

*

TIMESTAMP(expr) , TIMESTAMP(expr,expr2)

Con un único argumento, esta función retorna la expresión de fecha o fecha/hora expr como valor fecha/hora. Con dos argumentos, suma la expresión de hora expr2 a la expresión de fecha o de fecha/hora expr y retorna el resultado como valor fecha/hora.

mysql> SELECT TIMESTAMP('2003-12-31');
-> '2003-12-31 00:00:00'
mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');
-> '2004-01-01 00:00:00'

*

TIMESTAMPADD(interval,int_expr,datetime_expr)

Suma la expresión entera int_expr a la expresión de fecha o de fecha/hora datetime_expr. La unidad for int_expr la da el argumento interval , que debe ser uno de los siguientes valores: FRAC_SECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, o YEAR.

El valor interval puede especificarse usando una de las palabras claves que se muestran, o con un prefijo de SQL_TSI_. Por ejemplo, DAY o SQL_TSI_DAY son legales.

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
-> '2003-01-02 00:01:00'
mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');
-> '2003-01-09'

TIMESTAMPADD() está disponible desde MySQL 5.0.0.

*

TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)

Retorna la diferencia entera entre las expresiones de fecha o de fecha/hora datetime_expr1 y datetime_expr2. La unidad del resultado se da en el argumento interval. Los valores legales para interval son los mismos que los listados en la descripción de la función TIMESTAMPADD() .

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
-> 3
mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
-> -1

TIMESTAMPDIFF() está disponible desde MySQL 5.0.0.

*

TIME_FORMAT(time,format)

Se usa como la función DATE_FORMAT() pero la cadena format puede contener sólo los especificadores de formato que tratan horas, minutos y segundos. Otros especificadores producen un valor NULL o 0.

Si el valor time contiene una parte horaria mayor que 23, los especificadores de formato horario %H y %k producen un valor mayor que el rango usual de 0..23. Los otros especificadores de hora producen la hora modulo 12.

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
-> '100 100 04 04 4'

*

TIME_TO_SEC(time)

Retorna el argumento time convertido en segundos.

mysql> SELECT TIME_TO_SEC('22:23:00');
-> 80580
mysql> SELECT TIME_TO_SEC('00:39:38');
-> 2378

*

TO_DAYS(date)

Dada la fecha date, retorna un número de día (el número de dias desde el año 0).

mysql> SELECT TO_DAYS(950501);
-> 728779
mysql> SELECT TO_DAYS('1997-10-07');
-> 729669

TO_DAYS() no está pensado para usarse con valores anteriores al calendario Gregoriano (1582), ya que no tiene en cuenta los días perdidos cuando se cambió el calendario. Consulte Sección 12.6, “Qué calendario utiliza MySQL”.

Recuerde que MySQL convierte años de dos dígitos en fechas de cuatro dígitos usando las reglas en Sección 11.3, “Tipos de fecha y hora”. Por ejemplo, '1997-10-07' y '97-10-07' se consideran fechas idénticas:

mysql> SELECT TO_DAYS('1997-10-07'), TO_DAYS('97-10-07');
-> 729669, 729669

Para fechas anteriores a 1582 (y posiblemente un año posterior en otras localizaciones), los resultados de esta función no son fiables. Consulte Sección 12.6, “Qué calendario utiliza MySQL” para más detalles.

*

UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)

Si se llama sin argumentos, retorna el timestamp de Unix (segundos desde '1970-01-01 00:00:00' GMT) como entero sin signo. Si se llama a UNIX_TIMESTAMP() con un argumento date , retorna el valor del argumento como segundos desde '1970-01-01 00:00:00' GMT. date puede ser una cadena DATE , una cadena DATETIME , un TIMESTAMP, o un número en el formato YYMMDD o YYYYMMDD en hora local.

mysql> SELECT UNIX_TIMESTAMP();
-> 882226357
mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
-> 875996580

Cuando se usa UNIX_TIMESTAMP en una columna TIMESTAMP , la función retorna el valor del timestamp interno directamente, sin conversión implícita “string-to-Unix-timestamp” . Si pasa una fecha fuera de rango a UNIX_TIMESTAMP(), retorna 0, pero tenga en cuenta que sólo se hace un chequeo de rango básico (año de 1970 a 2037, mes de 01 a 12, día de 01 a 31).

Si quiere restar columnas UNIX_TIMESTAMP() puede querer convertir el resultado a enteros sin signo. Consulte Sección 12.8, “Funciones y operadores de cast”.

*

UTC_DATE, UTC_DATE()

Retorna la fecha UTC actual como valor en formato 'YYYY-MM-DD' o YYYYMMDD, dependiendo si la función se usa en un contexto numérico o de cadenas de caracteres.

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
-> '2003-08-14', 20030814

*

UTC_TIME, UTC_TIME()

Retorna la hora UTC actual como valor en formato 'HH:MM:SS' or HHMMSS dependiendo si la función se usa en un contexto numérico o de cadenas de caracteres.

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
-> '18:07:53', 180753

*

UTC_TIMESTAMP, UTC_TIMESTAMP()

Retorna la fecha y hora UTC actual como valor en formato 'YYYY-MM-DD HH:MM:SS' o YYYYMMDDHHMMSS dependiendo si la función se usa en un contexto numérico o de cadenas de caracteres.

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
-> '2003-08-14 18:08:04', 20030814180804

*

WEEK(date[,mode])

Esta función retorna el número de semana para date. La forma de dos argumentos de WEEK() le permite especificar si la semana comienza en lunes o domingo y si el valor de retorno debe estar en el rango de 0 a 53 o de 1 a 53. Si el argumento mode se omite en MySQL 5.0, el valor de la variable de sistema default_week_format se usa. Consulte Sección 5.3.3, “Variables de sistema del servidor”.

La siguiente tabla describe cómo funciona el argumento mode :

Primer día

Modo de semana Rango Semana 1 es la primera semana...
0 Domingo 0-53 con un domingo en este año
1 Lunes 0-53 con más de 3 días este año
2 Domingo 1-53 con un domingo este año
3 Lunes 1-53 con más de 3 días este año
4 Domingo 0-53 con más de 3 días este año
5 Lunes 0-53 con un lunes en este año
6 Domingo 1-53 con más de 3 días este año
7 Lunes 1-53 con un lunes en este año

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

Tenga en cuenta que si una fecha cae en la última semana del año prévio, MySQL retorna 0 si no usa 2, 3, 6, o 7 con el argumento opcional mode :

mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
-> 2000, 0

Se podría argumentar que MySQL debería retornar 52 para la función WEEK() , ya que la fecha dada ocurre en la 52a semana de 1999. Decidimos retornar 0 en su lugar porque queríamos que la función devolviera “el número de semana en el año dado.” Esta hace uso de la función WEEK() fiable combinada con otras funciones que extraen una parte de fecha de una fecha.

Si prefiere que el resultado a ser evaluado respecto al año que contiene el primer día de la semana para la fecha dada, debe usar 0, 2, 5, o 7 como el argumento mode opcional.

mysql> SELECT WEEK('2000-01-01',2);
-> 52

Alternativamente, use la función YEARWEEK():

mysql> SELECT YEARWEEK('2000-01-01');
-> 199952
mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);
-> '52'

*

WEEKDAY(date)

Retorna el índice de días de la semana para date (0 = lunes, 1 = martes, ... 6 = domingo).

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
-> 1
mysql> SELECT WEEKDAY('1997-11-05');
-> 2

*

WEEKOFYEAR(date)

Retorna la semana de la fecha como número del rango 1 a 53. Esta es una función de compatibilidad equivalente a WEEK(date,3).

mysql> SELECT WEEKOFYEAR('1998-02-20');
-> 8

*

YEAR(date)

Retorna el año para date, en el rango 1000 a 9999.

mysql> SELECT YEAR('98-02-03');
-> 1998

*

YEARWEEK(date), YEARWEEK(date,start)

Retorna año y semana para una fecha. El argumento start funciona exactamente como el argumento start de WEEK(). El año en el resultado puede ser diferente del año en el argumento fecha para la primera y última semana del año.

mysql> SELECT YEARWEEK('1987-01-01');
-> 198653

Tenga en cuenta que el número de semana es diferente de lo que la función WEEK() retornaría (0) para argumentos opcionales 0 o 1, como WEEK() retorna la semana en el contexto del año dado.



Manuel Salazar
fuente de informacion : http://dev.mysql.com/doc/refman/5.0/es/date-and-time-functions.html

21 de noviembre de 2007 a las 22:43

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)