Tengo un flotador columna con los números de diferente longitud y estoy tratando de convertir a varchar.

Algunos valores superan bigint tamaño máximo, así que no puedo hacer algo como esto

cast(cast(float_field as bigint) as varchar(100))

He intentado usar decimales, pero los números no son del mismo tamaño, por lo que esto no ayuda demasiado

CONVERT(varchar(100), Cast(float_field as decimal(38, 0)))

Cualquier ayuda es muy apreciada.

ACTUALIZACIÓN:

Valor de ejemplo es 2.2000012095022 E+26.

  • cast(float_field as varchar(max)) de lo contrario, no entiendo la pregunta
  • valor para su reparto es de 2.2 e+026. Probablemente usted no consigue la quesion 🙂
InformationsquelleAutor hgulyan | 2010-09-15

14 Comentarios

  1. 232

    Trate de usar el STR() función.

    SELECT STR(float_field, 25, 5)

    STR() Función


    Otra nota: este pastillas a la izquierda con espacios. Si esto es un problema de combinar con LTRIM:

    SELECT LTRIM(STR(float_field, 25, 5))
    • Tengo ************************* . ¿Qué es eso? 🙂
    • ¿Select LTRIM(Str(float_field, 38, 0)) De trabajo para sus datos?
    • Smith, parece que funciona, pero de la misma manera como decimales, por lo que no estoy seguro si es el valor real(últimos diez dígitos son cero). Supongo, que el valor real se había perdido. Gracias!
    • últimos diez dígitos son cero, porque eso es lo que el último parámetro es en el Str función. El número de dígitos después del punto decimal. Has leído el enlace que he publicado? Cambiar el cero a 10. Select LTRIM(Str(float_field, 38, 10))
    • Me gustaría que hubiera una advertencia en SSMS «hey, al convertir esa errónea de flotación de teléfono campo de texto, esté preparado para obtener un buen número de teléfono con la notación científica! no somos lo suficientemente inteligentes como para ltrim(str) en primer lugar»…
    • es un flotador, no es persise a 25 dígitos. str(float_field,17,15) trabajará para números menores de 1 y str(float_field,16,15) de más de 1. (en uno agrega un 0 que cuenta para el total)
    • Esto no resuelve problema más amplio – en este caso es necesario especificar la precisión y la escala que es muy conveniente cuando usted ve un número. Pero, ¿cómo hacer que la hora de seleccionar diferentes carrozas a partir de una base de datos…

  2. 41

    La consulta sólo poco he encontrado que devuelve el mismo número original es

    CONVERT (VARCHAR(50), float_field,128)

    Ver http://www.connectsql.com/2011/04/normal-0-microsoftinternetexplorer4.html

    Las otras soluciones de arriba a veces ronda o agregar dígitos al final

    ACTUALIZACIÓN: Según comentarios de abajo y de lo que puedo ver en https://msdn.microsoft.com/en-us/library/ms187928.aspx:

    CONVERT (VARCHAR(50), float_field,3)

    Debe ser utilizado en las nuevas versiones de SQL Server (Base de datos de SQL Azure, y a partir de SQL Server 2016 RC3)

    • +1 para @adinas, el valor de tipo float se convierte como él, pero con la excepción de 0 valor de tipo float se va a convertir como 0.0E0. Lo que necesitaba para convertir el flotador de campo a varchar como tengo que mostrar NA cuando NULL y 0 como es. He logrado esto mediante la adición de CASE declaración en la consulta de la siguiente manera; CASE WHEN float_field IS NULL THEN 'NA' WHEN float_field = 0 THEN '0' ELSE CONVERT(VARCHAR, float_field, 128) END AS float_As_VChar
    • Según el documento en Microsoft – msdn.microsoft.com/en-us/library/ms187928.aspx, el 128 de la sintaxis se incluye por motivos de compatibilidad, y puede ser depreceated en una versión futura
    • 128 está en desuso, pero 3 parece ser el reemplazo para él en el más reciente de SQL Server libera.
  3. 12

    esta es la solución terminé usando en sqlserver 2012 (dado que todas las otras sugerencias tenía el inconveniente de truncar la parte fraccionaria o algún otro inconveniente).

    declare @float float = 1000000000.1234;
    select format(@float, N'#.##############################');

    de salida:

    1000000000.1234

    esto tiene la ventaja adicional (en mi caso) para hacer el separador de miles y la localización fácil:

    select format(@float, N'#,##0.##########', 'de-DE');

    de salida:

    1.000.000.000,1234
  4. 3

    Tema útil, gracias.

    Si quieres como me quite la dirección cero puede utilizar que :

    DECLARE @MyFloat [float];
    SET @MyFloat = 1000109360.050;
    SELECT REPLACE(RTRIM(REPLACE(REPLACE(RTRIM(LTRIM(REPLACE(STR(@MyFloat, 38, 16), '0', ' '))), ' ', '0'),'.',' ')),' ',',')
  5. 2

    flotador sólo tiene un máximo. precisión de 15 dígitos. Dígitos después del 15 de posición son, por tanto, al azar, y la conversión a bigint (max. 19 dígitos) o decimal no ayuda.

    • No lo entiendo. El valor del campo es 2.2000012095022 E+26. ¿Cuál es la solución? No hay ninguna?
    • usted no puede conseguir más dígitos mediante la conversión a string que hay dígitos almacenados en el valor original.
    • Así que he perdido dígitos después del 15 de posición?
    • Había algún tipo de problema con los datos. Sólo tengo que actualizar ese valor con un 15 dígitos de flotación. Voy a aceptar tu respuesta, porque describe principal problema que he tenido con este tipo de datos. Gracias.
  6. 2

    Esto puede ayudar sin redondeo

    declare @test float(25)
    
    declare @test1 decimal(10,5)
    
    select @test = 34.0387597207
    select @test
    set @test1 = convert (decimal(10,5), @test)
    select cast((@test1) as varchar(12))
    
    
    Select  LEFT(cast((@test1) as varchar(12)),LEN(cast((@test1) as varchar(12)))-1)
  7. 2

    Convertir en un integer primero y luego en un string:

    cast((convert(int,b.tax_id)) as varchar(20))
    • Esto eliminará los dígitos después de la coma decimal, si los hubiere. Por lo tanto, esta solución no es exacta.
  8. 1

    Si utiliza una función CLR, usted puede convertir el flotador a una cadena que se ve igual que el flotador, sin todos los extras 0 en la final.

    Función CLR

    [Microsoft.SqlServer.Server.SqlFunction(DataAccess = DataAccessKind.Read)]
    [return: SqlFacet(MaxSize = 50)]
    public static SqlString float_to_str(double Value, int TruncAfter)
    {
      string rtn1 = Value.ToString("R");
      string rtn2 = Value.ToString("0." + new string('0', TruncAfter));
    
      if (rtn1.Length < rtn2.Length) { return rtn1; } else { return rtn2; }
    }

    .

    Ejemplo

    create table #temp (value float)
    insert into #temp values (0.73), (0), (0.63921), (-0.70945), (0.28), (0.72000002861023), (3.7), (-0.01), (0.86), (0.55489), (0.439999997615814)
    
    select value,
           dbo.float_to_str(value, 18) as converted,
           case when value = cast(dbo.float_to_str(value, 18) as float) then 1 else 0 end as same
    from   #temp
    
    drop table #temp

    .

    Salida

    value                  converted                  same
    ---------------------- -------------------------- -----------
    0.73                   0.73                       1
    0                      0                          1
    0.63921                0.63921                    1
    -0.70945               -0.70945                   1
    0.28                   0.28                       1
    0.72000002861023       0.72000002861023           1
    3.7                    3.7                        1
    -0.01                  -0.01                      1
    0.86                   0.86                       1
    0.55489                0.55489                    1
    0.439999997615814      0.439999997615814          1

    .

    Advertencia

    Todas convertir cadenas de caracteres se truncan a las 18 decimales, y no hay ceros a la derecha. 18 dígitos de precisión no es un problema para nosotros. Y, el 100% de nuestros FP números (cerca de 100.000 valores) parecen idénticos como valores de cadena como lo hacen en la base de datos como FP números.

  9. 1

    Probar esto, debería funcionar:

    cast((convert(bigint,b.tax_id)) as varchar(20))
  10. 0

    Modificado Axel respuesta un poco ya que en ciertos casos se producen resultados no deseados.

    DECLARE @MyFloat [float];
    SET @MyFloat = 1000109360.050;
    
    SELECT REPLACE(RTRIM(REPLACE(REPLACE(RTRIM((REPLACE(CAST(CAST(@MyFloat AS DECIMAL(38,18)) AS VARCHAR(max)), '0', ' '))), ' ', '0'),'.',' ')),' ','.')
  11. 0
    select replace(myFloat, '', '')

    de REPLACE() documentación:

    Devuelve nvarchar si uno de los argumentos de entrada es de tipo de datos nvarchar; de lo contrario, REEMPLACE devuelve varchar.

    Devuelve NULL si alguno de los argumentos es NULO.

    pruebas:

    null ==> [NULL]

    1.11 ==> 1.11

    1.10 ==> 1.1

    1.00 ==> 1

    0.00 ==> 0

    -1.10 ==> -1.1

    0.00001 ==> 1e-005

    0.000011 ==> 1.1 e-005

  12. 0

    Seleccione

    cast(sustituir(convert(decimal(15,2),acs_daily_debit), ‘.’, ‘,’) como varchar(20))

    de acs_balance_details

  13. 0

    Moleculares basadas en la respuesta:

    DECLARE @F FLOAT = 1000000000.1234;
    SELECT @F AS Original, CAST(FORMAT(@F, N'#.##############################') AS VARCHAR) AS Formatted;
    
    SET @F = 823399066925.049
    SELECT @F AS Original, CAST(@F AS VARCHAR) AS Formatted
    UNION ALL SELECT @F AS Original, CONVERT(VARCHAR(128), @F, 128) AS Formatted
    UNION ALL SELECT @F AS Original, CAST(FORMAT(@F, N'G') AS VARCHAR) AS Formatted;
    
    SET @F = 0.502184537571209
    SELECT @F AS Original, CAST(@F AS VARCHAR) AS Formatted
    UNION ALL SELECT @F AS Original, CONVERT(VARCHAR(128), @F, 128) AS Formatted
    UNION ALL SELECT @F AS Original, CAST(FORMAT(@F, N'G') AS VARCHAR) AS Formatted;
  14. 0

    Me encontré con una situación similar y fue sorprendido por los problemas de redondeo de ‘números muy grandes», presentado dentro de SSMS v17.9.1 /SQL 2017.

    No estoy sugiriendo que tengo una solución, sin embargo he observado que FORMATO presenta un número que aparece correcto. No puedo implica esto reduce aún más problemas de redondeo o es útil dentro de una complicada función matemática.

    T Código SQL suministrados que debe demuestran claramente mis observaciones, mientras que permitan a los demás para probar su código y de las ideas, de surgir la necesidad.

    WITH Units AS 
    (
       SELECT 1.0 AS [RaisedPower] , 'Ten' As UnitDescription
       UNION ALL
       SELECT 2.0 AS [RaisedPower] , 'Hundred' As UnitDescription
       UNION ALL
       SELECT 3.0 AS [RaisedPower] , 'Thousand' As UnitDescription
       UNION ALL
       SELECT 6.0 AS [RaisedPower] , 'Million' As UnitDescription
       UNION ALL
       SELECT 9.0 AS [RaisedPower] , 'Billion' As UnitDescription
       UNION ALL
       SELECT 12.0 AS [RaisedPower] , 'Trillion' As UnitDescription
       UNION ALL
       SELECT 15.0 AS [RaisedPower] , 'Quadrillion' As UnitDescription
       UNION ALL
       SELECT 18.0 AS [RaisedPower] , 'Quintillion' As UnitDescription
       UNION ALL
       SELECT 21.0 AS [RaisedPower] , 'Sextillion' As UnitDescription
       UNION ALL
       SELECT 24.0 AS [RaisedPower] , 'Septillion' As UnitDescription
       UNION ALL
       SELECT 27.0 AS [RaisedPower] , 'Octillion' As UnitDescription
       UNION ALL
       SELECT 30.0 AS [RaisedPower] , 'Nonillion' As UnitDescription
       UNION ALL
       SELECT 33.0  AS [RaisedPower] , 'Decillion' As UnitDescription
    
    )
    
    SELECT UnitDescription
    
       ,              POWER( CAST(10.0 AS FLOAT(53)) , [RaisedPower] )                                                             AS ReturnsFloat
       ,        CAST( POWER( CAST(10.0 AS FLOAT(53)) , [RaisedPower] )  AS NUMERIC (38,0) )                                        AS RoundingIssues
       , STR(   CAST( POWER( CAST(10.0 AS FLOAT(53)) , [RaisedPower] )  AS NUMERIC (38,0) ) ,   CAST([RaisedPower] AS INT) + 2, 0) AS LessRoundingIssues
       , FORMAT(      POWER( CAST(10.0 AS FLOAT(53)) , [RaisedPower] )  , '0')                                                     AS NicelyFormatted
    
    FROM Units
    ORDER BY [RaisedPower]

Dejar respuesta

Please enter your comment!
Please enter your name here