Cómo devolver solo la fecha de un tipo de datos DateTime de SQL Server

On SQL Server 2008 y más alto, deberías CONVERT hasta la fecha:

SELECT CONVERT(date, getdate())

En versiones anteriores, puede hacer lo siguiente:

SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date))

por ejemplo

SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))

me da

2008-09-22 00:00:00.000

Pros:

• No varchar<->datetime conversiones requeridas
• No hay necesidad de pensar en locale

Como lo sugirió Michael

Utilice esta variante: SELECT DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)

select getdate()

SELECT DATEADD(hh, DATEDIFF(hh, 0, getdate()), 0)
SELECT DATEADD(hh, 0, DATEDIFF(hh, 0, getdate()))

SELECT DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, getdate()))

SELECT DATEADD(mm, DATEDIFF(mm, 0, getdate()), 0)
SELECT DATEADD(mm, 0, DATEDIFF(mm, 0, getdate()))

SELECT DATEADD(yy, DATEDIFF(yy, 0, getdate()), 0)
SELECT DATEADD(yy, 0, DATEDIFF(yy, 0, getdate()))

Salida:

2019-04-19 08:09:35.557

2019-04-19 08:00:00.000
4763-02-17 00:00:00.000

2019-04-19 00:00:00.000
2019-04-19 00:00:00.000

2019-04-01 00:00:00.000
1903-12-03 00:00:00.000

2019-01-01 00:00:00.000
1900-04-30 00:00:00.000

SQLServer 2008 ahora tiene un tipo de datos de 'fecha' que contiene solo una fecha sin componente de hora. Cualquiera que utilice SQLServer 2008 y más allá puede hacer lo siguiente:

SELECT CONVERT(date, GETDATE())

Si usa SQL 2008 y superior:

select cast(getdate() as date)

DATEADD y DATEDIFF son mejores que CONVERTing a varchar. Ambas consultas tienen el mismo plan de ejecución, pero los planes de ejecución son principalmente sobre datos estrategias de acceso y no siempre revelan los costos implícitos involucrados en el tiempo de la CPU para realizar todas las piezas. Si ambas consultas se ejecutan en una tabla con millones de filas, el tiempo de CPU usando DateDiff puede ser cercano a 1/3 del tiempo de conversión de CPU.

Para ver los planes de ejecución de las consultas:

set showplan_text on
GO 

Tanto DATEADD como DATEDIFF ejecutarán un CONVERT_IMPLICIT.

Aunque la solución CONVERT es más simple y más fácil de leer para algunos, is Más lento. No hay necesidad de volver a la fecha y hora (esto lo hace implícitamente el servidor). Tampoco hay una necesidad real en el método DateDiff para DateAdd posteriormente, ya que el resultado entero también se convertirá implícitamente a datetime.

SELECCIONE CONVERT (varchar, MyDate, 101) FROM DatesTable

  |--Compute Scalar(DEFINE:([Expr1004]=CONVERT(varchar(30),[TEST].[dbo].[DatesTable].[MyDate],101)))
       |--Table Scan(OBJECT:([TEST].[dbo].[DatesTable]))

SELECT DATEADD (dd, 0, DATEDIFF (dd, 0, MyDate)) FROM DatesTable

  |--Compute Scalar(DEFINE:([Expr1004]=dateadd(day,(0),CONVERT_IMPLICIT(datetime,datediff(day,'1900-01-01 00:00:00.000',CONVERT_IMPLICIT(datetime,[TEST].[dbo].[DatesTable].[MyDate],0)),0))))
       |--Table Scan(OBJECT:([TEST].[dbo].[DatesTable]))

El uso de FLOOR () como sugirió @digi tiene un rendimiento más cercano a DateDiff, pero no se recomienda ya que convertir el tipo de datos de fecha y hora para flotar y retroceder no siempre produce el valor original.

Recuerden chicos: no le crean a nadie. ¡Mire las estadísticas de rendimiento y pruébelo usted mismo!

Tenga cuidado cuando esté probando sus resultados. Seleccionar muchas filas para el cliente ocultará la diferencia de rendimiento porque lleva más tiempo enviar las filas a través de la red que realizar los cálculos. Por lo tanto, asegúrese de que el servidor realice el trabajo de todas las filas, pero no se envíe ningún conjunto de filas al cliente.

Parece haber confusión para algunas personas acerca de cuándo la optimización de la caché afecta las consultas. La ejecución de dos consultas en el mismo lote o en lotes separados no tiene ningún efecto sobre el almacenamiento en caché. Por lo tanto, puede caducar el caché manualmente o simplemente ejecutar las consultas varias veces. Cualquier optimización para la consulta n. ° 2 también afectaría a las consultas posteriores, así que descarte la ejecución n. ° 1 si lo desea.

Esta es guión de prueba completo y resultados de rendimiento que demuestran que DateDiff es sustancialmente más rápido que convertir a varchar.

Prueba esto:

SELECT CONVERT(VARCHAR(10),GETDATE(),111)

La declaración anterior convierte su formato actual a YYYY/MM/DD, por favor refiérase a este enlace para elegir su formato preferido.

SELECT CONVERT(datetime, CONVERT(varchar, GETDATE(), 101))

Para devolución en formato de fecha

CAST (OrderDate AS fecha)

El código anterior funcionará en SQL Server 2010

Regresará como el 12/12/2013

Para SQL Server 2012 use el siguiente código

CONVERT(VARCHAR(10), OrderDate , 111)

Puede utilizar el CONVERT función para devolver solo la fecha. Vea los enlaces a continuación:

Manipulación de fecha y hora en SQL Server 2000

CAST y CONVERT

La sintaxis para usar la función de conversión es:

CONVERT ( data_type [ ( length ) ] , expression [ , style ] ) 

Si necesita el resultado como varchar, deberías pasar por

SELECT CONVERT(DATE, GETDATE()) --2014-03-26
SELECT CONVERT(VARCHAR(10), GETDATE(), 111) --2014/03/26

que ya se mencionó anteriormente.

Si necesita un resultado en formato de fecha y hora, debe utilizar cualquiera de las consultas siguientes

1. SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 111)) AS OnlyDate 
   

   2014-03-26 00:00:00.000

2. SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 112)) AS OnlyDate 
   

   2014-03-26 00:00:00.000

3. DECLARE  @OnlyDate DATETIME
   SET @OnlyDate = DATEDIFF(DD, 0, GETDATE())
   SELECT @OnlyDate AS OnlyDate
   

   2014-03-26 00:00:00.000

Si está utilizando SQL Server 2012 o versiones posteriores,

Utilice la herramienta Format() función.

Ya existen múltiples respuestas y tipos de formato para el servidor SQL. Pero la mayoría de los métodos son algo ambiguos y le resultaría difícil recordar los números para el tipo de formato o las funciones con respecto al formato de fecha específico. Es por eso que en las próximas versiones del servidor SQL existe una mejor opción.

FORMAT ( value, format [, culture ] )

La opción de cultura es muy útil, ya que puede especificar la fecha según sus espectadores.

Debe recordar d (para patrones pequeños) y D (para patrones largos).

1. "d": patrón de fecha corto.

2009-06-15T13:45:30 -> 6/15/2009 (en-US)
2009-06-15T13:45:30 -> 15/06/2009 (fr-FR)
2009-06-15T13:45:30 -> 2009/06/15 (ja-JP)

2. "D": patrón de fecha larga.

2009-06-15T13:45:30 -> Monday, June 15, 2009 (en-US)
2009-06-15T13:45:30 -> 15 июня 2009 г. (ru-RU)
2009-06-15T13:45:30 -> Montag, 15. Juni 2009 (de-DE)

Más ejemplos en consulta.

DECLARE @d DATETIME = '10/01/2011';
SELECT FORMAT ( @d, 'd', 'en-US' ) AS 'US English Result'
      ,FORMAT ( @d, 'd', 'en-gb' ) AS 'Great Britain English Result'
      ,FORMAT ( @d, 'd', 'de-de' ) AS 'German Result'
      ,FORMAT ( @d, 'd', 'zh-cn' ) AS 'Simplified Chinese (PRC) Result'; 

SELECT FORMAT ( @d, 'D', 'en-US' ) AS 'US English Result'
      ,FORMAT ( @d, 'D', 'en-gb' ) AS 'Great Britain English Result'
      ,FORMAT ( @d, 'D', 'de-de' ) AS 'German Result'
      ,FORMAT ( @d, 'D', 'zh-cn' ) AS 'Chinese (Simplified PRC) Result';

US English Result Great Britain English Result  German Result Simplified Chinese (PRC) Result
----------------  ----------------------------- ------------- -------------------------------------
10/1/2011         01/10/2011                    01.10.2011    2011/10/1

US English Result            Great Britain English Result  German Result                    Chinese (Simplified PRC) Result
---------------------------- ----------------------------- -----------------------------  ---------------------------------------
Saturday, October 01, 2011   01 October 2011               Samstag, 1. Oktober 2011        2011年10月1日

Si desea más formatos, puede ir a:

1. Cadenas de formato de fecha y hora estándar
2. Cadenas de formato de fecha y hora personalizadas

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),103) --21/09/2011

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),101) --09/21/2011

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),111) --2011/09/21

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),107) --Sep 21, 2011

Usando FLOOR () - simplemente corte la parte de tiempo.

SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)

SI desea utilizar CONVERT y obtener el mismo resultado que en la pregunta original planteada, es decir, aaaa-mm-dd, utilice CONVERT(varchar(10),[SourceDate as dateTime],121) El mismo código que el par anterior responde, pero el código para convertir a aaaa-mm-dd con guiones es 121.

Si puedo entrar en mi tribuna por un segundo, este tipo de formato no pertenece al nivel de datos, y es por eso que no fue posible sin 'trucos' tontos de alta sobrecarga hasta SQL Server 2008, cuando se introducen los tipos de datos de fecha real. Hacer tales conversiones en el nivel de datos es una gran pérdida de sobrecarga en su DBMS, pero lo más importante es que en el segundo que hace algo como esto, básicamente ha creado datos huérfanos en la memoria que supongo que luego volverá a un programa. No puede volver a colocarlo en otra columna 3NF + o compararlo con cualquier cosa escrita sin revertir, por lo que todo lo que ha hecho es introducir puntos de falla y eliminar la referencia relacional.

SIEMPRE debe continuar y devolver su tipo de datos dateTime al programa de llamada y en el nivel PRESENTACIÓN, realice los ajustes necesarios. Tan pronto como vaya a convertir cosas antes de devolvérselas a la persona que llama, está eliminando toda esperanza de integridad referencial de la aplicación. Esto evitaría una operación ACTUALIZAR o ELIMINAR, nuevamente, a menos que realice algún tipo de reversión manual, que nuevamente expondrá sus datos a un error humano / código / gremlin cuando no es necesario.

SELECT DATEADD(DD, DATEDIFF(DD, 0, GETDATE()), 0)

SELECT DATEADD(DAY, 0, DATEDIFF(DAY,0, GETDATE()))

SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 101))

Editar: Los dos primeros métodos son esencialmente los mismos y superan el método de conversión a varchar.

Para obtener el resultado indicado, utilizo el siguiente comando.

SELECT CONVERT(DATETIME,CONVERT(DATE,GETDATE()))

Creo que es útil.

 Convert(nvarchar(10), getdate(), 101) --->  5/12/14

 Convert(nvarchar(12), getdate(), 101) --->  5/12/2014

Si asigna los resultados a una columna o variable, asígnele el tipo FECHA y la conversión será implícita.

DECLARE @Date DATE = GETDATE()   

SELECT @Date   --> 2017-05-03

Creo que esto funcionaría en tu caso:

CONVERT(VARCHAR(10),Person.DateOfBirth,111) AS BirthDate
//here date is obtained as 1990/09/25

DECLARE @yourdate DATETIME = '11/1/2014 12:25pm'    
SELECT CONVERT(DATE, @yourdate)

Bien, aunque llego un poco tarde :), aquí está la otra solución.

SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) as DATETIME)

Resultado

2008-09-22 00:00:00.000

Y si está utilizando SQL Server 2012 y superior, puede utilizar FORMAT() funciona así -

SELECT FORMAT(GETDATE(), 'yyyy-MM-dd')

Fecha:

SELECT CONVERT (fecha, GETDATE ()) SELECT CAST (GETDATE () como fecha)

Hora:

SELECT CONVERT (hora, GETDATE (), 114) SELECT CAST (GETDATE () como hora)

En este caso, solo la fecha, vamos a ejecutar esta consulta:

SELECCIONAR CONVERTIR (VARCHAR (10), getdate (), 111);

Incluso usando el antiguo MSSQL Server 7.0, el código aquí (cortesía de este aquí) me permitió obtener el formato de fecha que estaba buscando en ese momento:

PRINT '1) Date/time in format MON DD YYYY HH:MI AM (OR PM): ' + CONVERT(CHAR(19),GETDATE())  
PRINT '2) Date/time in format MM-DD-YY: ' + CONVERT(CHAR(8),GETDATE(),10)  
PRINT '3) Date/time in format MM-DD-YYYY: ' + CONVERT(CHAR(10),GETDATE(),110) 
PRINT '4) Date/time in format DD MON YYYY: ' + CONVERT(CHAR(11),GETDATE(),106)
PRINT '5) Date/time in format DD MON YY: ' + CONVERT(CHAR(9),GETDATE(),6) 
PRINT '6) Date/time in format DD MON YYYY HH:MM:SS:MMM(24H): ' + CONVERT(CHAR(24),GETDATE(),113)

Produjo esta salida:

1) Date/time in format MON DD YYYY HH:MI AM (OR PM): Feb 27 2015  1:14PM
2) Date/time in format MM-DD-YY: 02-27-15
3) Date/time in format MM-DD-YYYY: 02-27-2015
4) Date/time in format DD MON YYYY: 27 Feb 2015
5) Date/time in format DD MON YY: 27 Feb 15
6) Date/time in format DD MON YYYY HH:MM:SS:MMM(24H): 27 Feb 2015 13:14:46:630

Simplemente puedes hacerlo de esta manera:

SELECT CONVERT(date, getdate())
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date))
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))

Salidas como:

2008-09-22 00:00:00.000

O simplemente hazlo así:

SELECT CONVERT (DATE, GETDATE()) 'Date Part Only'

Resultado:

Date Part Only
--------------
2013-07-14

Solo haz:

SELECT CAST(date_variable AS date)

o con PostgreSQL:

SELECT date_variable::date

¿Por qué no usas DATE_FORMAT (your_datetiem_column, '% d-% m-% Y')?

EX: select DATE_FORMAT( some_datetime_column, '%d-%m-%Y' ) from table_name

puede cambiar la secuencia de m, dy año reorganizando '%d-%m-%Y' parte

Sé que esto es antiguo, pero no veo dónde alguien lo dijo de esta manera. Por lo que puedo decir, este es el estándar ANSI.

SELECT CAST(CURRENT_TIMESTAMP AS DATE)

Sería bueno si Microsoft también pudiera admitir la variable CURRENT_DATE del estándar ANSI.

Estoy a favor de lo siguiente que no se mencionó:

DATEFROMPARTS(DATEPART(yyyy, @mydatetime), DATEPART(mm, @mydatetime), DATEPART(dd, @mydatetime))

Tampoco le importa lo local o hacer una doble conversión, aunque cada 'datepart' probablemente hace matemáticas. Por lo tanto, puede ser un poco más lento que el método de dateiff, pero para mí es mucho más claro. Especialmente cuando quiero agrupar solo por año y mes (establezca el día en 1).

A partir de SQL SERVER 2012, puede hacer esto:

SELECT FORMAT(GETDATE(), 'yyyy-MM-dd 00:00:00.000')

En SQL Server 2000

CAST(
(
    STR( YEAR( GETDATE() ) ) + '/' +
    STR( MONTH( GETDATE() ) ) + '/' +
    STR( DAY( GETDATE() ) )
)
AS DATETIME)