T-SQL de type VARCHAR(MAX) Tronquée

DECLARE @str VARCHAR (MAX);

SELECT @str = COALESCE(@str + CHAR(10), '') +
       'EXECUTE CreateDeno ' + CAST(ID AS VARCHAR) 
FROM   GL_To_Batch_Details
WHERE  TYPE = 'C' AND
       Deno_ID IS NULL;

--PRINT @str;--SELECT @str;
**EXEC(@str);**

ÉDITÉ

Ne EXECUTE instruction truncate chaînes à 8 000 caractères comme PRINT? Comment puis-je exécuter une instruction SQL dynamique ayant plus de 8 000 caractères?

Toute suggestion serait chaudement apprécié.

Je pense que vous êtes confus, vous ne pouvez pas PRINT plus de 8000 caractères, cela ne signifie pas que @str est tronqué
J'ai édité la question pour être plus précis sur le problème. En fait, quand EXÉCUTER produite l'erreur, j'ai utilisé l'IMPRESSION de voir quelle a été la dynamique de T-SQL généré. Dans les deux cas, nvarchar(MAX) a été tronqué. Des idées?

OriginalL'auteur Nick Binnet | 2011-09-12

tsql

13

PRINT est limitée à 8k en sortie.

Il y a aussi un 8k limite dans SSMS volet des résultats.

Aller à

outils -> options -> query résultats

pour voir les options.

Pour vérifier la longueur des données réelles, vérifier:

SELECT LEN(@str)

Ok. L'IMPRESSION est utilisé ici à la place de EXEC pour voir quel est le véritable problème.
Bennet: MSDN dit: Dans les versions antérieures de SQL Server, les chaînes de caractères sont limitées à 8 000 octets. Cela nécessite de concaténer des chaînes pour l'exécution dynamique. Dans SQL Server 2005, varchar(max) et de type nvarchar(max) types de données peuvent être spécifiées afin de permettre les chaînes de caractères à être jusqu'à 2 gigaoctets de données.
J'ai eu à utiliser de type NVARCHAR(MAX) type de données avec sp_executesql afin de le faire fonctionner. Pourriez-vous s'il vous plaît confirmer la même chose peut être réalisé sans l'aide de sp_executesql? Merci.

OriginalL'auteur JNK
4

Lors de la concaténation de chaînes de caractères et le résultat est de type VARCHAR(MAX) et est de plus de 8000 caractères, au moins un paramètre et/ou de l'élément utilisé dans la concaténation doivent être de type VARCHAR(MAX) type sinon la troncature se fera dans la chaîne résultante et ne sera pas exécutable dans une instruction EXEC.

Exemple:
```
DECLARE @sql AS VARCHAR(MAX);
/* DECLARE @someItem AS VARCHAR(100); -- WILL CAUSE TRUNCATION WHEN @sql HAS LEN > 8000 */
DECLARE @someItem AS VARCHAR(MAX); -- All string variables need to be VARCHAR(MAX) when concatenating to another VARCHAR(MAX)

SET @someItem = 'Just assume the resulting @sql variable goes over 8000 characters...';
SET @sql = 'SELECT Something FROM Somewhere WHERE SomeField = ''' + @someItem + '''';

EXEC (@sql);
--PRINT @sql;
```
Plus d'informations sur MSDN.

"Si le résultat de la concaténation de chaînes de caractères dépasse la limite de
8 000 octets, le résultat est tronqué. Cependant, si au moins l'un des
chaînes concaténées est un type de grande valeur, la troncature n'est pas
se produire."

OriginalL'auteur WayneJohn
2

La longueur par défaut d'un varchar est de 30 caractères:
```
CAST (ID AS VARCHAR) 
```
Est-il possible que id est de plus de 30 caractères?

Non, il n'est pas possible pour l'ID étant de plus de 30 caractères.
C'est une bonne pratique de ne jamais utiliser de la longueur par défaut, il y a d'autres fois où la valeur par défaut len est 1.

OriginalL'auteur Andomar
2

La PRINT de commande est certainement limitée à 8000 caractères, indépendamment de la durée de la sortie (ou si elle est de type varchar(max)). Pour contourner cela, vous avez besoin à la sortie de la chaîne dans des morceaux de <8000 caractères

Mise à jour: En réponse à votre modifier, exec ne limite pas la longueur de la chaîne. J'ai mis en place l'exemple suivant pour afficher ce:
```
DECLARE @str VARCHAR (MAX);


;WITH CTE_Count AS
(
    select counter = 1
    union all
    select counter = counter+1
    from CTE_Count
    Where counter < 2000

)
SELECT             
    @str=COALESCE(@str + CHAR (10) ,
        '' ) + 'select value=' + CAST (counter AS VARCHAR) 
from
    CTE_Count

Option (MAXRECURSION 0)

PRINT len(@str);--SELECT @str;

exec (@str)
```
L'exécution de cette commande affiche la longueur de la 34892 caractères, et tous à l'an 2000 exécuter des instructions faire exécuter (attention, cela peut prendre quelques minutes!)

OriginalL'auteur Jon Egerton
0

Il se passe quand vous concaténer les littéraux si on n'est pas un type varchar(max), le résultat mal-être "implicite coulé" varchar(8000).

Pour générer un littéral de type varchar(max) toutes les pièces doivent être de type varchar(max).
Remarque: Il m'est arrivé de faire des mises à jour sur les colonnes varchar(max), jamais testé avec la commande EXEC.

Également comme indiqué dans les précédents répond à la commande d'impression est titulaire d'une limite, mais vous pouvez essayer de sélectionner la variable au lieu de l'imprimer. (également ther est une limite que choisir la longueur que vous pouvez configurer sur MS-SMS)

OriginalL'auteur jean

Je voulais aussi voir ce que j'ai été l'envoi d'Exec, et a été confondu par la limite de tirage. Dû écrire un proc à imprimer en morceaux.

CREATE PROCEDURE [dbo].[KFX_PrintVarcharMax] 
    @strMax varchar(max)
AS
BEGIN
    SET NOCOUNT ON;

    DECLARE 
        @index int = 0,
        @start int = 1,
        @blkSize int = 2000;


    WHILE @Start < LEN(@strMax)
    BEGIN
        IF @start + @blkSize >= LEN(@strMax)
        BEGIN
            -- If remainder is less than blocksize print the remainder, and exit.
            PRINT SUBSTRING(@strMax, @start, @blkSize)
            BREAK;
        END
        -- Else find the next terminator (beyond the blksize)
        SET @index = CHARINDEX(CHAR(10), @strMax, @start + @blkSize);
        if @index >= @start
        BEGIN
            PRINT SubString(@strMax, @start, @index - @start + 1)
            SET @start = @index + 1;
            SET @blkSize  = CASE WHEN @start + 2000 < LEN(@strMax) THEN 2000 
                            ELSE LEN(@strMax) - @start + 1 END
        END
        ELSE
        BEGIN
            -- No char(10) found.  Just print the rest.
            PRINT SUBSTRING(@strMax, @start, LEN(@strMax))
            BREAK;
        END 
    END

END

OriginalL'auteur Darrel Lee

Vous devez vous connecter pour publier un commentaire.