Jak wstawić podział wiersza w łańcuchu VARCHAR / NVARCHAR programu SQL Server

Nie widziałem podobnych pytań na ten temat i musiałem to zbadać pod kątem czegoś, nad czym teraz pracuję. Pomyślałem, że opublikuję odpowiedź na to pytanie, gdyby ktoś inny miał to samo pytanie.

char(13)jest CR. W przypadku łamania linii w stylu DOS / Windows CRLFchcesz char(13)+char(10):

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

Znalazłem odpowiedź tutaj: http://blog.sqlauthority.com/2007/08/22/sql-server-t-sql-script-to-insert-carriage-return-and-new-line-feed-in- kod/

Po prostu konkatenujesz ciąg i wstawiasz miejsce, w CHAR(13)którym chcesz łamać linię.

Przykład:

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

Spowoduje to wydrukowanie następujących elementów:

To jest linia 1.
To jest linia 2.

Innym sposobem na to jest:

INSERT CRLF SELECT 'fox 
jumped'

Oznacza to, że po prostu wstawienie podziału wiersza w zapytaniu podczas pisania spowoduje dodanie podobnego podziału do bazy danych. Działa to w SQL Server Management studio i Query Analyzer. Wierzę, że to zadziała również w języku C #, jeśli użyjesz znaku @ na ciągach.

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

Uruchom to w SSMS, pokazuje, jak podziały wiersza w samym SQL stają się częścią wartości ciągu obejmujących linie:

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))

Wynik:
Linia 1
Linia 2
Linia 3

Jak długi jest pusty wiersz?
2)

Jakie są wartości ASCII?
13
10

Lub jeśli wolisz podać swój ciąg w jednym wierszu (prawie!), Możesz użyć REPLACE()takiego (opcjonalnie użyć CHAR(13)+CHAR(10)jako zamiennika):

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

Po Google ...

Pobieranie kodu ze strony internetowej:

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))

Wygląda na to, że można to zrobić, zastępując symbol zastępczy znakiem CHAR (13)

Dobre pytanie, nigdy nie zrobiłem tego sam :)

Dotarłem tutaj, ponieważ martwiłem się, że cr-lfs, które podałem w ciągach C #, nie były pokazywane w odpowiedziach na zapytania SQl Server Management Studio.

Okazuje się, że tam są, ale nie są wyświetlane.

Aby „zobaczyć” cr-lfs, użyj instrukcji print, takiej jak:

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

Oto funkcja C #, która wstawia wiersz tekstowy do istniejącego obiektu blob tekstowego, ograniczonego przez CRLF i zwraca wyrażenie T-SQL odpowiednie dla operacji INSERTlub UPDATEoperacji. Ma w sobie część naszej zastrzeżonej obsługi błędów, ale kiedy go rozprujesz, może być pomocny - mam nadzieję, że tak.

/// <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("");
    }
}

Powiedziałbym

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

lub

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

To zawsze jest fajne, ponieważ kiedy dostajesz wyeksportowane listy, powiedzmy Oracle, wtedy dostajesz rekordy obejmujące kilka linii, co z kolei może być interesujące dla, powiedzmy, plików cvs, więc uważaj.

W każdym razie odpowiedź Roba jest dobra, ale radzę użyć czegoś innego niż @, spróbuj jeszcze raz, na przykład §§ @@ §§ lub coś takiego, aby miał szansę na wyjątkowość. (Ale pamiętaj o długości pola varchar/ do nvarcharktórego wstawiasz ...)

Wszystkie te opcje działają w zależności od sytuacji, ale żadna z nich może nie działać, jeśli używasz SSMS (jak wspomniano w niektórych komentarzach SSMS ukrywa CR / LF)

Więc zamiast jeździć po zakręcie, sprawdź to ustawienie

Tools | Options