Cómo insertar un salto de línea en una cadena VARCHAR / NVARCHAR de SQL Server

No vi ninguna pregunta similar sobre este tema, y ​​tuve que investigar esto para algo en lo que estoy trabajando en este momento. Pensé en publicar la respuesta en caso de que alguien más tuviera la misma pregunta.

char(13)es CR. Para los saltos de línea de estilo DOS / Windows CRLF, desea char(13)+char(10), como:

'This is line 1.' + CHAR(13)+CHAR(10) + 'This is line 2.'

Encontré la respuesta aquí: http://blog.sqlauthority.com/2007/08/22/sql-server-t-sql-script-to-insert-carriage-return-and-new-line-feed-in- código/

Simplemente concatene la cadena e inserte un lugar CHAR(13)donde desee su salto de línea.

Ejemplo:

DECLARE @text NVARCHAR(100)
SET @text = 'This is line 1.' + CHAR(13) + 'This is line 2.'
SELECT @text

Esto imprime lo siguiente:

Esta es la línea 1.
Esta es la línea 2.

Otra forma de hacer esto es como tal:

INSERT CRLF SELECT 'fox 
jumped'

Es decir, simplemente insertando un salto de línea en su consulta mientras lo escribe agregará el salto similar a la base de datos. Esto funciona en SQL Server Management Studio y Query Analyzer. Creo que esto también funcionará en C # si usa el signo @ en las cadenas.

string str = @"INSERT CRLF SELECT 'fox 
    jumped'"

Ejecute esto en SSMS, muestra cómo los saltos de línea en el propio SQL se convierten en parte de los valores de cadena que abarcan líneas:

PRINT 'Line 1
Line 2
Line 3'
PRINT ''

PRINT 'How long is a blank line feed?'
PRINT LEN('
')
PRINT ''

PRINT 'What are the ASCII values?'
PRINT ASCII(SUBSTRING('
',1,1))
PRINT ASCII(SUBSTRING('
',2,1))

Resultado:
Línea 1
Línea 2
Línea 3

¿Cuánto dura un avance de línea en blanco?
2

¿Cuáles son los valores ASCII?
13
10

O si prefiere especificar su cadena en una línea (¡casi!) Podría emplearla de REPLACE()esta manera (opcionalmente, usarla CHAR(13)+CHAR(10)como reemplazo):

PRINT REPLACE('Line 1`Line 2`Line 3','`','
')

Siguiendo un Google ...

Tomando el código del sitio web:

CREATE TABLE CRLF
    (
        col1 VARCHAR(1000)
    )

INSERT CRLF SELECT 'The quick brown@'
INSERT CRLF SELECT 'fox @jumped'
INSERT CRLF SELECT '@over the '
INSERT CRLF SELECT 'log@'

SELECT col1 FROM CRLF

Returns:

col1
-----------------
The quick brown@
fox @jumped
@over the
log@

(4 row(s) affected)


UPDATE CRLF
SET col1 = REPLACE(col1, '@', CHAR(13))

Parece que se puede hacer reemplazando un marcador de posición con CHAR (13)

Buena pregunta, nunca lo hice yo mismo :)

Llegué aquí porque me preocupaba que los cr-lfs que especifiqué en las cadenas de C # no se mostraran en las respuestas de consulta de SQl Server Management Studio.

Resulta que están allí, pero no se muestran.

Para "ver" el cr-lfs, use la instrucción print como:

declare @tmp varchar(500)    
select @tmp = msgbody from emailssentlog where id=6769;
print @tmp

Aquí hay una función C # que antepone una línea de texto a un blob de texto existente, delimitado por CRLF, y devuelve una expresión T-SQL adecuada para INSERTu UPDATEoperaciones. Tiene algo de nuestro manejo de errores patentado, pero una vez que lo elimine, puede ser útil, espero que sea así.

/// <summary>
/// Generate a SQL string value expression suitable for INSERT/UPDATE operations that prepends
/// the specified line to an existing block of text, assumed to have \r\n delimiters, and
/// truncate at a maximum length.
/// </summary>
/// <param name="sNewLine">Single text line to be prepended to existing text</param>
/// <param name="sOrigLines">Current text value; assumed to be CRLF-delimited</param>
/// <param name="iMaxLen">Integer field length</param>
/// <returns>String: SQL string expression suitable for INSERT/UPDATE operations.  Empty on error.</returns>
private string PrependCommentLine(string sNewLine, String sOrigLines, int iMaxLen)
{
    String fn = MethodBase.GetCurrentMethod().Name;

    try
    {
        String [] line_array = sOrigLines.Split("\r\n".ToCharArray());
        List<string> orig_lines = new List<string>();
        foreach(String orig_line in line_array) 
        { 
            if (!String.IsNullOrEmpty(orig_line))  
            {  
                orig_lines.Add(orig_line);    
            }
        } // end foreach(original line)

        String final_comments = "'" + sNewLine + "' + CHAR(13) + CHAR(10) ";
        int cum_length = sNewLine.Length + 2;
        foreach(String orig_line in orig_lines)
        {
            String curline = orig_line;
            if (cum_length >= iMaxLen) break;                // stop appending if we're already over
            if ((cum_length+orig_line.Length+2)>=iMaxLen)    // If this one will push us over, truncate and warn:
            {
                Util.HandleAppErr(this, fn, "Truncating comments: " + orig_line);
                curline = orig_line.Substring(0, iMaxLen - (cum_length + 3));
            }
            final_comments += " + '" + curline + "' + CHAR(13) + CHAR(10) \r\n";
            cum_length += orig_line.Length + 2;
        } // end foreach(second pass on original lines)

        return(final_comments);


    } // end main try()
    catch(Exception exc)
    {
        Util.HandleExc(this,fn,exc);
        return("");
    }
}

Yo diría que

concat('This is line 1.', 0xd0a, 'This is line 2.')

o

concat(N'This is line 1.', 0xd000a, N'This is line 2.')

Esto siempre es genial, porque cuando obtienes listas exportadas de, digamos Oracle, obtienes registros que abarcan varias líneas, lo que a su vez puede ser interesante para, por ejemplo, archivos cvs, así que ten cuidado.

De todos modos, la respuesta de Rob es buena, pero aconsejaría usar algo más que @, intente algunos más, como §§ @@ §§ o algo así, de modo que tenga la posibilidad de un poco de singularidad. (Pero aún así, recuerda la longitud del campo varchar/ en el nvarcharque estás insertando ...)

Todas estas opciones funcionan según su situación, pero es posible que no vea que ninguna de ellas funciona si está utilizando SSMS (como se menciona en algunos comentarios, SSMS oculta CR / LF)

Entonces, en lugar de conducir por la curva, verifique esta configuración en

Tools | Options