Mejor enfoque para eliminar parte de tiempo de datetime en SQL Server

En SQL Server 2008, puede usar:

CONVERT(DATE, getdate(), 101)

Por supuesto, este es un hilo viejo, pero para hacerlo completo.

Desde SQL 2008 puede usar el tipo de datos DATE para que simplemente pueda hacer:

SELECT CONVERT(DATE,GETDATE())

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

En SQL Server 2008, hay un tipo de datos DATE (también un tipo de datos TIME).

CAST(GetDate() as DATE)

O

declare @Dt as DATE = GetDate()

Aquí hay otra respuesta, de otra pregunta duplicada:

SELECT CAST(CAST(getutcdate() - 0.50000004 AS int) AS datetime) 

Este método de número mágico funciona ligeramente más rápido que el método DATEADD. (Parece ~10%)

El tiempo de CPU en varias rondas de un millón de registros:

DATEADD   MAGIC FLOAT
500       453
453       360
375       375
406       360

Pero tenga en cuenta que estos números son posiblemente irrelevantes porque ya son MUY rápidos. A menos que tuviera conjuntos de registros de 100,000 o más, ni siquiera podía obtener el tiempo de CPU para leer por encima de cero.

Considerando el hecho de que DateAdd está destinado para este propósito y es más robusto, yo diría que use DateAdd.

SELECT CAST(CAST(GETDATE() AS DATE) AS DATETIME)

Elimine el tiempo en insertos/actualizaciones en primer lugar. En cuanto a la conversión sobre la marcha, nada puede superar a una función definida por el usuario en cuanto a la capacidad de mantenimiento:

select date_only(dd)

La implementación de date_only puede ser lo que quieras, ahora está abstraída y llamar al código es mucho más limpio.

Ver esta pregunta:
¿Cómo puedo truncar una datetime en SQL Server?

Hagas lo que hagas, no uses el método string. Es la peor manera de hacerlo.

Ya contestado, pero voy a tirar esto por ahí también... esto supuestamente también se preforma bien, pero funciona desechando el decimal (que almacena el tiempo) del flotador y devolviendo solo la parte completa (que es la fecha)

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

Segunda vez que encontré esta solución... tomé este código de

CAST(round(cast(getdate()as real),0,1) AS datetime)

Este método no utiliza la función string. Date es básicamente un tipo de datos real con dígitos antes del decimal son fracción de un día.

Esto supongo que será más rápido que mucho.

Para mí el siguiente código siempre es un ganador:

SELECT CONVERT(DATETIME, FLOOR(CONVERT(FLOAT,GETDATE())));

CUIDADO!

Los métodos a) y b) NO siempre tienen la misma salida!

select DATEADD(dd, DATEDIFF(dd, 0, '2013-12-31 23:59:59.999'), 0)

Salida: 2014-01-01 00:00:00.000

select cast(convert(char(11), '2013-12-31 23:59:59.999', 113) as datetime)

Salida: 2013-12-31 00:00:00.000

(Probado en MS SQL Server 2005 y 2008 R2)

EDITAR: De acuerdo con el comentario de Adam, esto no puede suceder si lee el valor de fecha de la tabla, pero puede suceder si proporciona su valor de fecha como un literal (ejemplo: como un parámetro de un procedimiento almacenado llamado via ADO.NET).

Seleccione CONVERTIR(char (10), GetDate (), 126)

Me gusta mucho:

[date] = CONVERT(VARCHAR(10), GETDATE(), 120)

El código de formato 120 forzará la fecha a la norma ISO 8601:

'YYYY-MM-DD' or '2017-01-09'

Súper fácil de usar en dplyr (R) y pandas (Python)!

Creo que quieres decir cast(floor(cast(getdate()as float))as datetime)

Real es solo 32 bits, y podría perder cierta información

Esto es lo más rápido cast(cast(getdate()+x-0.5 as int)as datetime)

...aunque solo un 10% más rápido (about 0.49 microseconds CPU vs. 0.58)

Esto fue recomendado, y toma el mismo tiempo en mi prueba justo ahora: DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)

En SQL 2008, la función CLR de SQL es aproximadamente 5 veces más rápida de lo que sería usar una función SQL, a 1.35 microsegundos frente a 6.5 microsecciones, lo que indica una sobrecarga de llamadas a funciones mucho menor para una función CLR de SQL frente a una SQL UDF.

En SQL 2005, la función CLR de SQL es 16 veces más rápida, según mis pruebas, en comparación con esta función lenta:

create function dateonly (  @dt datetime )
returns datetime
as
begin
return cast(floor(cast(@dt as float))as int)
end

¿Qué tal select cast(cast my_datetime_field as date) as datetime)? Esto resulta en la misma fecha, con la hora establecida en 00: 00, pero evita cualquier conversión a texto y también evita cualquier redondeo numérico explícito.

Creo que si te quedas estrictamente con TSQL que esta es la forma más rápida de truncar el tiempo:

 select convert(datetime,convert(int,convert(float,[Modified])))

Encontré que este método de truncamiento es aproximadamente un 5% más rápido que el método DateAdd. Y esto se puede modificar fácilmente para redondear al día más cercano de esta manera:

select convert(datetime,ROUND(convert(float,[Modified]),0))

Aquí hice una función para eliminar algunas partes de un datetime para SQL Server. Uso:

• El primer parámetro es la fecha y hora a eliminar.
• El segundo parámetro es un char:
  • s: redondea a segundos; elimina milisegundos
  • m: redondea a minutos; elimina segundos y milisegundos
  • h: redondea a horas; elimina minutos, segundos y milisegundos.
  • d: redondea a días; elimina horas, minutos, segundos y milisegundos.
• Devuelve el nuevo datetime

create function dbo.uf_RoundDateTime(@dt as datetime, @part as char) returns datetime as begin if CHARINDEX( @part, 'smhd',0) = 0 return @dt; return cast( Case @part when 's' then convert(varchar(19), @dt, 126) when 'm' then convert(varchar(17), @dt, 126) + '00' when 'h' then convert(varchar(14), @dt, 126) + '00:00' when 'd' then convert(varchar(14), @dt, 112) end as datetime ) end

Por si acaso alguien está buscando aquí una versión de Sybase ya que varias de las versiones anteriores no funcionaron

CAST(CONVERT(DATE,GETDATE(),103) AS DATETIME)

• Probado en I SQL v11 ejecutándose en Adaptive Server 15.7

Si es posible, para cosas especiales como esta, me gusta usar funciones CLR.

En este caso:

[Microsoft.SqlServer.Server.SqlFunction]
    public static SqlDateTime DateOnly(SqlDateTime input)
    {
        if (!input.IsNull)
        {
            SqlDateTime dt = new SqlDateTime(input.Value.Year, input.Value.Month, input.Value.Day, 0, 0, 0);

            return dt;
        }
        else
            return SqlDateTime.Null;
    }

Yo, personalmente, casi siempre uso User Defined functions para esto si se trata de SQL Server 2005 (o una versión inferior), sin embargo, debe tenerse en cuenta que hay inconvenientes específicos al usar UDF, especialmente si se aplican a las cláusulas WHERE (ver más abajo y los comentarios sobre esta respuesta para más detalles). Si utiliza SQL Server 2008 (o superior), consulte a continuación.

De hecho, para la mayoría de las bases de datos que creo, agrego estos UDF en justo cerca del comienzo ya que sé que hay un 99% es posible que tarde o temprano los necesite.

Creo uno para "solo fecha" y "solo hora" (aunque el "solo fecha" es, con mucho, el más utilizado de los dos).

Aquí hay algunos enlaces a una variedad de UDF relacionados con la fecha:

Funciones esenciales de Fecha, Hora y DateTime de SQL Server
Función Get Date Only

Ese último enlace muestra no menos de 3 formas diferentes de obtener la fecha solo parte de un campo datetime y menciona algunos pros y contras de cada aproximación.

Si se utiliza un UDF, debe tenerse en cuenta que se debe tratar de evitar el uso del UDF como parte de una cláusula WHERE en una consulta, ya que esto dificultará en gran medida el rendimiento de la consulta. La razón principal de esto es que el uso de un UDF en una cláusula WHERE hace que esa cláusula sea no sargable, lo que significa que SQL Server ya no puede usar un índice con esa cláusula para mejorar la velocidad de ejecución de la consulta. Con referencia a mi propio uso de UDF, usaré con frecuencia el columna de fecha " raw " dentro de la cláusula WHERE, pero aplique el UDF a la columna seleccionada. De esta manera, el UDF solo se aplica al conjunto de resultados filtrado y no a todas las filas de la tabla como parte del filtro.

Por supuesto, el mejor enfoque absoluto para esto es usar SQL Server 2008 (o superior) y separar sus fechas y horas, ya que el motor de base de datos de SQL Server proporciona de forma nativa los componentes de fecha y hora individuales, y puede consultar independientemente sin la necesidad de un UDF u otro mecanismo para extraer la parte fecha u hora de un tipo datetime compuesto.

Usaría:

CAST
(
CAST(YEAR(DATEFIELD) as varchar(4)) + '/' CAST(MM(DATEFIELD) as varchar(2)) + '/' CAST(DD(DATEFIELD) as varchar(2)) as datetime
) 

Creando así efectivamente un nuevo campo a partir del campo de fecha que ya tiene.