Exécuter un gros script SQL (avec les commandes GO)

89

J'ai besoin d'exécuter un grand ensemble d'instructions SQL (créant un tas de tables, vues et procédures stockées) à partir d'un programme C #.

Ces instructions doivent être séparées par des GOinstructions, mais SqlCommand.ExecuteNonQuery()n'aime pas les GOinstructions. Ma solution, que je suppose que je publierai pour référence, était de diviser la chaîne SQL en GOlignes et d'exécuter chaque lot séparément.

Existe-t-il un moyen plus simple / meilleur?

c# sql-server Blorgbeard est sorti
la source

Réponses:

105

Utilisez des objets de gestion SQL Server (SMO) qui comprennent les séparateurs GO. Voir mon article de blog ici: http://weblogs.asp.net/jongalloway/Handling-_2200_GO_2200_-Separators-in-SQL-Scripts- 2D00 -the-easy-way

Exemple de code:

public static void Main()    
{        
  string scriptDirectory = "c:\\temp\\sqltest\\";
  string sqlConnectionString = "Integrated Security=SSPI;" +
  "Persist Security Info=True;Initial Catalog=Northwind;Data Source=(local)";
  DirectoryInfo di = new DirectoryInfo(scriptDirectory);
  FileInfo[] rgFiles = di.GetFiles("*.sql");
  foreach (FileInfo fi in rgFiles)
  {
        FileInfo fileInfo = new FileInfo(fi.FullName);
        string script = fileInfo.OpenText().ReadToEnd();
        using (SqlConnection connection = new SqlConnection(sqlConnectionString))
        {
            Server server = new Server(new ServerConnection(connection));
            server.ConnectionContext.ExecuteNonQuery(script);
        }
   }
}

Si cela ne fonctionne pas pour vous, consultez la bibliothèque de Phil Haack qui gère cela: http://haacked.com/archive/2007/11/04/a-library-for-executing-sql-scripts-with-go-separators -et.aspx

Jon Galloway
la source
2
Comment cela peut-il être intégré à une transaction? Le code lève une InvalidOperationException lors de la création de ServerConnection avec SqlConnection qui a une transaction en attente sur elle.
benPearce
1
Cette solution fonctionne, je veux juste ajouter que si vous souhaitez utiliser des transactions avec un TransactionScopeobjet, il vous suffit d'enregistrer la connexion avec la transaction ambiante actuelle. Vérifiez ma réponse ici: stackoverflow.com/a/18322938/1268570
Jupaol
fonctionne très bien, mais pouvons-nous utiliser SqlConnection.InfoMessage) pour voir le résultat dans l'application C # ou enregistrer le résultat dans un txtfichier, juste pour savoir si le script a été exécuté avec succès, car récemment en utilisant sqlcmdquand j'ai exécuté un fichier de script de 150 Mo sur un hôte distant, après 55 minutes les lignes ont été effectuées avec cette erreur, TCP Provider: An existing connection was forcibly closed by the remote host., communication link failure. , aucune des lignes affectées ne peut être connue, mais je suis préoccupé par les messages d'erreur lors de l'exécution du fichier de script généré par la base de données.
shaijut
5
Ces solutions ont provoqué un échec de votre code lorsque certaines DLL SQL ne sont pas installées sur la machine. .NET utilise des DLL intégrées à Windows. L'absence de certains packs de fonctionnalités SQL (y compris les objets de gestion) peut empêcher des erreurs telles que «Microsoft.SqlServer.SqlClrProvider.dll» introuvable. En le corrigeant (ce n'est pas un travail facile), la prochaine erreur sera 'Microsoft.SqlServer.BathParser.dll' etc Trouvez une autre solution pour assurer la flexibilité de votre application.
Alexandr Sargsyan
35

C'est ce que j'ai rassemblé pour résoudre mon problème immédiat.

private void ExecuteBatchNonQuery(string sql, SqlConnection conn) {
    string sqlBatch = string.Empty;
    SqlCommand cmd = new SqlCommand(string.Empty, conn);
    conn.Open();
    sql += "\nGO";   // make sure last batch is executed.
    try {
        foreach (string line in sql.Split(new string[2] { "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries)) {
            if (line.ToUpperInvariant().Trim() == "GO") {
                cmd.CommandText = sqlBatch;
                cmd.ExecuteNonQuery();
                sqlBatch = string.Empty;
            } else {
                sqlBatch += line + "\n";
            }
        }            
    } finally {
        conn.Close();
    }
}

Cela nécessite que les commandes GO soient sur leur propre ligne et ne détectera pas les commentaires de bloc, donc ce genre de chose sera divisé et provoquera une erreur:

ExecuteBatchNonQuery(@"
    /*
    GO
    */", conn);
Blorgbeard est sorti
la source
C'est bien que je puisse facilement adapter cela à SqlCe si nécessaire - l'autre code utilise des classes et des commandes de connexion Sql.
Blue Toque
Je veux exécuter ce code avec un script SQL contenant plusieurs procédures stockées, mais je suis un peu confus, où lit-il le SQL? Lorsque vous faites référence au «dernier lot», parlez-vous du code SQL? Et si oui, comment détermineriez-vous le dernier lot, et que se passerait-il si je voulais exécuter tous les lots et pas seulement le dernier? Je connais trop de questions, mais merci si vous avez le temps de répondre.
user1676874
Vous passez le SQL à la fonction sous forme de chaîne: string sql- c'est tout le script. Quand je fais référence à un "lot", je veux dire un morceau de code SQL entre deux instructions "GO". Le code ajoute un GOà la fin du script afin que le code à l'intérieur de foreachne saute pas le dernier lot si vous n'avez pas terminé votre script par un GO. Ainsi, le code tel qu'il est écrit exécutera tout le SQL.
Blorgbeard sort
J'ai créé une méthode d'extension: classe statique interne SqlCommandHelper {vide statique interne ExecuteBatchNonQuery (ce cmd SqlCommand, chaîne sql)
— Rob Sedgwick
1
Si vous voulez être un peu plus efficace, vous pouvez utiliser à la StringBuilder sqlBatchplace.
— Lii
11

Vous pouvez utiliser des objets de gestion SQL pour effectuer cela. Ce sont les mêmes objets que Management Studio utilise pour exécuter des requêtes. Je crois que Server.ConnectionContext.ExecuteNonQuery()fera ce dont vous avez besoin.

— tbreffni
source
6

Le mot-clé de séparateur de lots "GO" est en fait utilisé par SQL Management Studio lui-même, afin qu'il sache où terminer les lots qu'il envoie au serveur, et il n'est pas transmis au serveur SQL. Vous pouvez même changer le mot-clé dans Management Studio, si vous le souhaitez.

— John Hubert
source
5

Je regarde cela plusieurs fois à la fin décidé avec l' implémentation EF Un peu modifié pourSqlConnection

public static void ExecuteSqlScript(this SqlConnection sqlConnection, string sqlBatch)
        {
            // Handle backslash utility statement (see http://technet.microsoft.com/en-us/library/dd207007.aspx)
            sqlBatch = Regex.Replace(sqlBatch, @"\\(\r\n|\r|\n)", string.Empty);

            // Handle batch splitting utility statement (see http://technet.microsoft.com/en-us/library/ms188037.aspx)
            var batches = Regex.Split(
                sqlBatch,
                string.Format(CultureInfo.InvariantCulture, @"^\s*({0}[ \t]+[0-9]+|{0})(?:\s+|$)", BatchTerminator),
                RegexOptions.IgnoreCase | RegexOptions.Multiline);

            for (int i = 0; i < batches.Length; ++i)
            {
                // Skip batches that merely contain the batch terminator
                if (batches[i].StartsWith(BatchTerminator, StringComparison.OrdinalIgnoreCase) ||
                    (i == batches.Length - 1 && string.IsNullOrWhiteSpace(batches[i])))
                {
                    continue;
                }

                // Include batch terminator if the next element is a batch terminator
                if (batches.Length > i + 1 &&
                    batches[i + 1].StartsWith(BatchTerminator, StringComparison.OrdinalIgnoreCase))
                {
                    int repeatCount = 1;

                    // Handle count parameter on the batch splitting utility statement
                    if (!string.Equals(batches[i + 1], BatchTerminator, StringComparison.OrdinalIgnoreCase))
                    {
                        repeatCount = int.Parse(Regex.Match(batches[i + 1], @"([0-9]+)").Value, CultureInfo.InvariantCulture);
                    }

                    for (int j = 0; j < repeatCount; ++j)
                    {
                       var command = sqlConnection.CreateCommand();
                       command.CommandText = batches[i];
                       command.ExecuteNonQuery();
                    }
                }
                else
                {
                    var command = sqlConnection.CreateCommand();
                    command.CommandText = batches[i];
                    command.ExecuteNonQuery();
                }
            }
        }
— Filip Cordas
source
Merci @Filip Cordas. Bien que cela ne soit pas marqué comme une réponse, cela m'a aidé comme un charme! Nous avions une grande quantité de scripts où le BatchTerminator était mentionné de différentes manières, comme des combinaisons de majuscules et de minuscules (go, Go, GO, etc.) et les temps maximum avaient des espaces de fin ou de début, ce qui posait un gros problème pour l'exécution via c # ... . Je vous remercie !!
— DipakRiswadkar
2
@DipakRiswadkar Oui verrouillé à cette question à quelques reprises et aucune des réponses fournies ne répond à mes besoins, alors j'ai regardé la mise en œuvre d'EF et j'ai donc posté la réponse.
— Filip Cordas
Réponse
— géniale
@Really devrait également le signaler à l'équipe Entity Framework. Comme je l'ai dit, ce n'était qu'une copie du passé avec peu de modifications.
— Filip Cordas
4

Basé sur la solution de Blorgbeard.

foreach (var sqlBatch in commandText.Split(new[] { "GO" }, StringSplitOptions.RemoveEmptyEntries))
{
   sqlCommand.CommandText = sqlBatch;
   sqlCommand.ExecuteNonQuery();
}
— Ryan Penfold
source
3
nouveau [] {"GO", "Go", "go"}
Andrew Veriga
1
nouveau [] {"GO", "Go", "go", "gO"}
Brandon Ward
Fonctionne tant que vous n'avez pas d'autre utilisation pour les deux lettres de votre code, comme les déclarations GOTO ou les commentaires.
Patrik
3

Si vous ne souhaitez pas utiliser SMO, par exemple parce que vous devez être multiplateforme, vous pouvez également utiliser la classe ScriptSplitter de SubText.

Voici l'implémentation en C # et VB.NET

Usage:

    string strSQL = @"
SELECT * FROM INFORMATION_SCHEMA.columns
GO
SELECT * FROM INFORMATION_SCHEMA.views
";

    foreach(string Script in new Subtext.Scripting.ScriptSplitter(strSQL ))
    {
        Console.WriteLine(Script);
    }

Si vous rencontrez des problèmes avec les commentaires de style C multilignes, supprimez les commentaires avec regex:

static string RemoveCstyleComments(string strInput)
{
    string strPattern = @"/[*][\w\d\s]+[*]/";
    //strPattern = @"/\*.*?\*/"; // Doesn't work
    //strPattern = "/\\*.*?\\*/"; // Doesn't work
    //strPattern = @"/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/ "; // Doesn't work
    //strPattern = @"/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/ "; // Doesn't work

    // http://stackoverflow.com/questions/462843/improving-fixing-a-regex-for-c-style-block-comments
    strPattern = @"/\*(?>(?:(?>[^*]+)|\*(?!/))*)\*/";  // Works !

    string strOutput = System.Text.RegularExpressions.Regex.Replace(strInput, strPattern, string.Empty, System.Text.RegularExpressions.RegexOptions.Multiline);
    Console.WriteLine(strOutput);
    return strOutput;
} // End Function RemoveCstyleComments

La suppression des commentaires sur une seule ligne est ici:

https://stackoverflow.com/questions/9842991/regex-to-remove-single-line-sql-comments
Stefan Steiger
la source
cette classe considère- /* Go */t-elle le cas?
edgarmtze
@cMinor: Pas dans le séparateur, mais vous pouvez supprimer les commentaires multilignes avec regex avant de vous séparer.
Stefan Steiger
2

J'ai également rencontré le même problème, et je ne pouvais trouver d'autre moyen que de diviser l'opération SQL unique en fichiers séparés, puis de les exécuter tous dans l'ordre.

Évidemment, le problème n'est pas avec les listes de commandes DML, elles peuvent être exécutées sans GO entre les deux; histoire différente avec DDL (créer, modifier, déposer ...)

ila
la source
2

Si vous ne voulez pas emprunter la route SMO, vous pouvez rechercher et remplacer "GO" par ";" et la requête comme vous le feriez. Notez que soly le dernier jeu de résultats sera renvoyé.

Jason Saldo
la source
1
Ils exécutent ExecuteNonQuery. C'est de loin le moyen le plus simple.
DaveMorganTexas
3
L'utilisation de "GO" vous permettra de redéfinir les mêmes variables dans la commande suivante du lot. Placer un point-virgule ne fera pas cela.
DDRider62
2

J'ai accompli cela aujourd'hui en chargeant mon SQL à partir d'un fichier texte dans une chaîne. J'ai ensuite utilisé la fonction de fractionnement de chaîne pour séparer la chaîne en commandes individuelles qui ont ensuite été envoyées individuellement au serveur. Simples :)

Je viens de réaliser que vous devez vous séparer sur \ nGO au cas où les lettres GO apparaissent dans l'un de vos noms de table, etc. Je suppose que j'ai eu de la chance là-bas!

Andy Dove
la source
2

Si vous ne souhaitez pas utiliser SMO (ce qui est mieux que la solution ci-dessous, mais je veux donner une alternative ...), vous pouvez diviser votre requête avec cette fonction.

C'est:

  • Preuve de commentaire (exemple --GO ou / * GO * /)
  • Ne fonctionne que sur une nouvelle ligne, tout comme dans SSMS (exemple / * test / * GO fonctionne et sélectionnez 1 comme aller non

  • Preuve de chaîne (exemple d'impression 'no go')

    private List<string> SplitScriptGo(string script)
{
    var result = new List<string>();
    int pos1 = 0;
    int pos2 = 0;
    bool whiteSpace = true;
    bool emptyLine = true;
    bool inStr = false;
    bool inComment1 = false;
    bool inComment2 = false;

    while (true)
    {
        while (pos2 < script.Length && Char.IsWhiteSpace(script[pos2]))
        {
            if (script[pos2] == '\r' || script[pos2] == '\n')
            {
                emptyLine = true;
                inComment1 = false;
            }

            pos2++;
        }

        if (pos2 == script.Length)
            break;

        bool min2 = (pos2 + 1) < script.Length;
        bool min3 = (pos2 + 2) < script.Length;

        if (!inStr && !inComment2 && min2 && script.Substring(pos2, 2) == "--")
            inComment1 = true;

        if (!inStr && !inComment1 && min2 && script.Substring(pos2, 2) == "/*")
            inComment2 = true;

        if (!inComment1 && !inComment2 && script[pos2] == '\'')
            inStr = !inStr;

        if (!inStr && !inComment1 && !inComment2 && emptyLine
            && (min2 && script.Substring(pos2, 2).ToLower() == "go")
            && (!min3 || char.IsWhiteSpace(script[pos2 + 2]) || script.Substring(pos2 + 2, 2) == "--" || script.Substring(pos2 + 2, 2) == "/*"))
        {
            if (!whiteSpace)
                result.Add(script.Substring(pos1, pos2 - pos1));

            whiteSpace = true;
            emptyLine = false;
            pos2 += 2;
            pos1 = pos2;
        }
        else
        {
            pos2++;
            whiteSpace = false;

            if (!inComment2)
                emptyLine = false;
        }

        if (!inStr && inComment2 && pos2 > 1 && script.Substring(pos2 - 2, 2) == "*/")
            inComment2 = false;
    }

    if (!whiteSpace)
        result.Add(script.Substring(pos1));

    return result;
}
Bigjim
la source
1

utilisez la méthode suivante pour diviser la chaîne et exécuter lot par lot

using System;
using System.IO;
using System.Text.RegularExpressions;
namespace RegExTrial
{
    class Program
    {
        static void Main(string[] args)
        {
            string sql = String.Empty;
            string path=@"D:\temp\sample.sql";
            using (StreamReader reader = new StreamReader(path)) {
                sql = reader.ReadToEnd();
            }            
            //Select any GO (ignore case) that starts with at least 
            //one white space such as tab, space,new line, verticle tab etc
            string pattern="[\\s](?i)GO(?-i)";

            Regex matcher = new Regex(pattern, RegexOptions.Compiled);
            int start = 0;
            int end = 0;
            Match batch=matcher.Match(sql);
            while (batch.Success) {
                end = batch.Index;
                string batchQuery = sql.Substring(start, end - start).Trim();
                //execute the batch
                ExecuteBatch(batchQuery);
                start = end + batch.Length;
                batch = matcher.Match(sql,start);
            }

        }

        private static void ExecuteBatch(string command)
        { 
            //execute your query here
        }

    }
}
Sriwantha Attanayake
la source
1

Pour éviter les tiers, les expressions régulières, les surcharges de mémoire et le travail rapide avec de gros scripts, j'ai créé mon propre analyseur basé sur les flux. Il

  • vérifie la syntaxe avant

  • peut reconnaître les commentaires avec - ou / ** /

    -- some commented text
 /*
drop table Users;
GO
   */

  • peut reconnaître les chaînes littérales avec 'ou "

    set @s =
    'create table foo(...);
    GO
    create index ...';
  • préserve le formatage LF et CR
  • préserve le bloc de commentaires dans les corps d'objets (procédures stockées, vues, etc.)

  • et d'autres constructions telles que

          gO -- commented text

Comment utiliser

    try
    {
        using (SqlConnection connection = new SqlConnection("Integrated Security=SSPI;Persist Security Info=True;Initial Catalog=DATABASE-NAME;Data Source=SERVER-NAME"))
        {
            connection.Open();

            int rowsAffected = SqlStatementReader.ExecuteSqlFile(
                "C:\\target-sql-script.sql",
                connection,
                // Don't forget to use the correct file encoding!!!
                Encoding.Default,
                // Indefinitely (sec)
                0
            );
        }
    }
    // implement your handlers
    catch (SqlStatementReader.SqlBadSyntaxException) { }
    catch (SqlException) { }
    catch (Exception) { }

Lecteur de script SQL basé sur le flux

class SqlStatementReader
{
    public class SqlBadSyntaxException : Exception
    {
        public SqlBadSyntaxException(string description) : base(description) { }
        public SqlBadSyntaxException(string description, int line) : base(OnBase(description, line, null)) { }
        public SqlBadSyntaxException(string description, int line, string filePath) : base(OnBase(description, line, filePath)) { }
        private static string OnBase(string description, int line, string filePath)
        {
            if (filePath == null)
                return string.Format("Line: {0}. {1}", line, description);
            else
                return string.Format("File: {0}\r\nLine: {1}. {2}", filePath, line, description);
        }
    }

    enum SqlScriptChunkTypes
    {
        InstructionOrUnquotedIdentifier = 0,
        BracketIdentifier = 1,
        QuotIdentifierOrLiteral = 2,
        DblQuotIdentifierOrLiteral = 3,
        CommentLine = 4,
        CommentMultiline = 5,
    }

    StreamReader _sr = null;
    string _filePath = null;
    int _lineStart = 1;
    int _lineEnd = 1;
    bool _isNextChar = false;
    char _nextChar = '\0';

    public SqlStatementReader(StreamReader sr)
    {
        if (sr == null)
            throw new ArgumentNullException("StreamReader can't be null.");

        if (sr.BaseStream is FileStream)
            _filePath = ((FileStream)sr.BaseStream).Name;

        _sr = sr;
    }

    public SqlStatementReader(StreamReader sr, string filePath)
    {
        if (sr == null)
            throw new ArgumentNullException("StreamReader can't be null.");

        _sr = sr;
        _filePath = filePath;
    }

    public int LineStart { get { return _lineStart; } }
    public int LineEnd { get { return _lineEnd == 1 ? _lineEnd : _lineEnd - 1; } }

    public void LightSyntaxCheck()
    {
        while (ReadStatementInternal(true) != null) ;
    }

    public string ReadStatement()
    {
        for (string s = ReadStatementInternal(false); s != null; s = ReadStatementInternal(false))
        {
            // skip empty
            for (int i = 0; i < s.Length; i++)
            {
                switch (s[i])
                {
                    case ' ': continue;
                    case '\t': continue;
                    case '\r': continue;
                    case '\n': continue;
                    default:
                        return s;
                }
            }
        }
        return null;
    }

    string ReadStatementInternal(bool syntaxCheck)
    {
        if (_isNextChar == false && _sr.EndOfStream)
            return null;

        StringBuilder allLines = new StringBuilder();
        StringBuilder line = new StringBuilder();
        SqlScriptChunkTypes nextChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
        SqlScriptChunkTypes currentChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
        char ch = '\0';
        int lineCounter = 0;
        int nextLine = 0;
        int currentLine = 0;
        bool nextCharHandled = false;
        bool foundGO;
        int go = 1;

        while (ReadChar(out ch))
        {
            if (nextCharHandled == false)
            {
                currentChunk = nextChunk;
                currentLine = nextLine;

                switch (currentChunk)
                {
                    case SqlScriptChunkTypes.InstructionOrUnquotedIdentifier:

                        if (ch == '[')
                        {
                            currentChunk = nextChunk = SqlScriptChunkTypes.BracketIdentifier;
                            currentLine = nextLine = lineCounter;
                        }
                        else if (ch == '"')
                        {
                            currentChunk = nextChunk = SqlScriptChunkTypes.DblQuotIdentifierOrLiteral;
                            currentLine = nextLine = lineCounter;
                        }
                        else if (ch == '\'')
                        {
                            currentChunk = nextChunk = SqlScriptChunkTypes.QuotIdentifierOrLiteral;
                            currentLine = nextLine = lineCounter;
                        }
                        else if (ch == '-' && (_isNextChar && _nextChar == '-'))
                        {
                            nextCharHandled = true;
                            currentChunk = nextChunk = SqlScriptChunkTypes.CommentLine;
                            currentLine = nextLine = lineCounter;
                        }
                        else if (ch == '/' && (_isNextChar && _nextChar == '*'))
                        {
                            nextCharHandled = true;
                            currentChunk = nextChunk = SqlScriptChunkTypes.CommentMultiline;
                            currentLine = nextLine = lineCounter;
                        }
                        else if (ch == ']')
                        {
                            throw new SqlBadSyntaxException("Incorrect syntax near ']'.", _lineEnd + lineCounter, _filePath);
                        }
                        else if (ch == '*' && (_isNextChar && _nextChar == '/'))
                        {
                            throw new SqlBadSyntaxException("Incorrect syntax near '*'.", _lineEnd + lineCounter, _filePath);
                        }
                        break;

                    case SqlScriptChunkTypes.CommentLine:

                        if (ch == '\r' && (_isNextChar && _nextChar == '\n'))
                        {
                            nextCharHandled = true;
                            currentChunk = nextChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
                            currentLine = nextLine = lineCounter;
                        }
                        else if (ch == '\n' || ch == '\r')
                        {
                            currentChunk = nextChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
                            currentLine = nextLine = lineCounter;
                        }
                        break;

                    case SqlScriptChunkTypes.CommentMultiline:

                        if (ch == '*' && (_isNextChar && _nextChar == '/'))
                        {
                            nextCharHandled = true;
                            nextChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
                            nextLine = lineCounter;
                        }
                        else if (ch == '/' && (_isNextChar && _nextChar == '*'))
                        {
                            throw new SqlBadSyntaxException("Missing end comment mark '*/'.", _lineEnd + currentLine, _filePath);
                        }
                        break;

                    case SqlScriptChunkTypes.BracketIdentifier:

                        if (ch == ']')
                        {
                            nextChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
                            nextLine = lineCounter;
                        }
                        break;

                    case SqlScriptChunkTypes.DblQuotIdentifierOrLiteral:

                        if (ch == '"')
                        {
                            if (_isNextChar && _nextChar == '"')
                            {
                                nextCharHandled = true;
                            }
                            else
                            {
                                nextChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
                                nextLine = lineCounter;
                            }
                        }
                        break;

                    case SqlScriptChunkTypes.QuotIdentifierOrLiteral:

                        if (ch == '\'')
                        {
                            if (_isNextChar && _nextChar == '\'')
                            {
                                nextCharHandled = true;
                            }
                            else
                            {
                                nextChunk = SqlScriptChunkTypes.InstructionOrUnquotedIdentifier;
                                nextLine = lineCounter;
                            }
                        }
                        break;
                }
            }
            else
                nextCharHandled = false;

            foundGO = false;
            if (currentChunk == SqlScriptChunkTypes.InstructionOrUnquotedIdentifier || go >= 5 || (go == 4 && currentChunk == SqlScriptChunkTypes.CommentLine))
            {
                // go = 0 - break, 1 - begin of the string, 2 - spaces after begin of the string, 3 - G or g, 4 - O or o, 5 - spaces after GO, 6 - line comment after valid GO
                switch (go)
                {
                    case 0:
                        if (ch == '\r' || ch == '\n')
                            go = 1;
                        break;
                    case 1:
                        if (ch == ' ' || ch == '\t')
                            go = 2;
                        else if (ch == 'G' || ch == 'g')
                            go = 3;
                        else if (ch != '\n' && ch != '\r')
                            go = 0;
                        break;
                    case 2:
                        if (ch == 'G' || ch == 'g')
                            go = 3;
                        else if (ch == '\n' || ch == '\r')
                            go = 1;
                        else if (ch != ' ' && ch != '\t')
                            go = 0;
                        break;
                    case 3:
                        if (ch == 'O' || ch == 'o')
                            go = 4;
                        else if (ch == '\n' || ch == '\r')
                            go = 1;
                        else
                            go = 0;
                        break;
                    case 4:
                        if (ch == '\r' && (_isNextChar && _nextChar == '\n'))
                            go = 5;
                        else if (ch == '\n' || ch == '\r')
                            foundGO = true;
                        else if (ch == ' ' || ch == '\t')
                            go = 5;
                        else if (ch == '-' && (_isNextChar && _nextChar == '-'))
                            go = 6;
                        else
                            go = 0;
                        break;
                    case 5:
                        if (ch == '\r' && (_isNextChar && _nextChar == '\n'))
                            go = 5;
                        else if (ch == '\n' || ch == '\r')
                            foundGO = true;
                        else if (ch == '-' && (_isNextChar && _nextChar == '-'))
                            go = 6;
                        else if (ch != ' ' && ch != '\t')
                            throw new SqlBadSyntaxException("Incorrect syntax was encountered while parsing go.", _lineEnd + lineCounter, _filePath);
                        break;
                    case 6:
                        if (ch == '\r' && (_isNextChar && _nextChar == '\n'))
                            go = 6;
                        else if (ch == '\n' || ch == '\r')
                            foundGO = true;
                        break;
                    default:
                        go = 0;
                        break;
                }
            }
            else
                go = 0;

            if (foundGO)
            {
                if (ch == '\r' || ch == '\n')
                {
                    ++lineCounter;
                }
                // clear GO
                string s = line.Append(ch).ToString();
                for (int i = 0; i < s.Length; i++)
                {
                    switch (s[i])
                    {
                        case ' ': continue;
                        case '\t': continue;
                        case '\r': continue;
                        case '\n': continue;
                        default:
                            _lineStart = _lineEnd;
                            _lineEnd += lineCounter;
                            return allLines.Append(s.Substring(0, i)).ToString();
                    }
                }
                return string.Empty;
            }

            // accumulate by string
            if (ch == '\r' && (_isNextChar == false || _nextChar != '\n'))
            {
                ++lineCounter;
                if (syntaxCheck == false)
                    allLines.Append(line.Append('\r').ToString());
                line.Clear();
            }
            else if (ch == '\n')
            {
                ++lineCounter;
                if (syntaxCheck == false)
                    allLines.Append(line.Append('\n').ToString());
                line.Clear();
            }
            else
            {
                if (syntaxCheck == false)
                    line.Append(ch);
            }
        }

        // this is the end of the stream, return it without GO, if GO exists
        switch (currentChunk)
        {
            case SqlScriptChunkTypes.InstructionOrUnquotedIdentifier:
            case SqlScriptChunkTypes.CommentLine:
                break;
            case SqlScriptChunkTypes.CommentMultiline:
                if (nextChunk != SqlScriptChunkTypes.InstructionOrUnquotedIdentifier)
                    throw new SqlBadSyntaxException("Missing end comment mark '*/'.", _lineEnd + currentLine, _filePath);
                break;
            case SqlScriptChunkTypes.BracketIdentifier:
                if (nextChunk != SqlScriptChunkTypes.InstructionOrUnquotedIdentifier)
                    throw new SqlBadSyntaxException("Unclosed quotation mark [.", _lineEnd + currentLine, _filePath);
                break;
            case SqlScriptChunkTypes.DblQuotIdentifierOrLiteral:
                if (nextChunk != SqlScriptChunkTypes.InstructionOrUnquotedIdentifier)
                    throw new SqlBadSyntaxException("Unclosed quotation mark \".", _lineEnd + currentLine, _filePath);
                break;
            case SqlScriptChunkTypes.QuotIdentifierOrLiteral:
                if (nextChunk != SqlScriptChunkTypes.InstructionOrUnquotedIdentifier)
                    throw new SqlBadSyntaxException("Unclosed quotation mark '.", _lineEnd + currentLine, _filePath);
                break;
        }

        if (go >= 4)
        {
            string s = line.ToString();
            for (int i = 0; i < s.Length; i++)
            {
                switch (s[i])
                {
                    case ' ': continue;
                    case '\t': continue;
                    case '\r': continue;
                    case '\n': continue;
                    default:
                        _lineStart = _lineEnd;
                        _lineEnd += lineCounter + 1;
                        return allLines.Append(s.Substring(0, i)).ToString();
                }
            }
        }

        _lineStart = _lineEnd;
        _lineEnd += lineCounter + 1;
        return allLines.Append(line.ToString()).ToString();
    }

    bool ReadChar(out char ch)
    {
        if (_isNextChar)
        {
            ch = _nextChar;
            if (_sr.EndOfStream)
                _isNextChar = false;
            else
                _nextChar = Convert.ToChar(_sr.Read());
            return true;
        }
        else if (_sr.EndOfStream == false)
        {
            ch = Convert.ToChar(_sr.Read());
            if (_sr.EndOfStream == false)
            {
                _isNextChar = true;
                _nextChar = Convert.ToChar(_sr.Read());
            }
            return true;
        }
        else
        {
            ch = '\0';
            return false;
        }
    }

    public static int ExecuteSqlFile(string filePath, SqlConnection connection, Encoding fileEncoding, int commandTimeout)
    {
        int rowsAffected = 0;
        using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
        {
            // Simple syntax check (you can comment out these two lines below)
            new SqlStatementReader(new StreamReader(fs, fileEncoding)).LightSyntaxCheck();
            fs.Seek(0L, SeekOrigin.Begin);

            // Read statements without GO
            SqlStatementReader rd = new SqlStatementReader(new StreamReader(fs, fileEncoding));
            string stmt;
            while ((stmt = rd.ReadStatement()) != null)
            {
                using (SqlCommand cmd = connection.CreateCommand())
                {
                    cmd.CommandText = stmt;
                    cmd.CommandTimeout = commandTimeout;
                    int i = cmd.ExecuteNonQuery();
                    if (i > 0)
                        rowsAffected += i;
                }
            }
        }
        return rowsAffected;
    }
}
Yargo
la source
0

J'ai eu le même problème en java et je l'ai résolu avec un peu de logique et de regex. Je crois que la même logique peut être appliquée. Premièrement, j'ai lu le fichier slq en mémoire. Ensuite, j'applique la logique suivante. C'est à peu près ce qui a été dit auparavant, mais je pense que l'utilisation de la liaison de mots regex est plus sûre que d'attendre un nouveau caractère de ligne.

String pattern = "\\bGO\\b|\\bgo\\b";

String[] splitedSql = sql.split(pattern);
for (String chunk : splitedSql) {
  getJdbcTemplate().update(chunk);
}

Cela divise essentiellement la chaîne sql en un tableau de chaînes sql. Le regex sert essentiellement à détecter les mots «go» complets, en minuscules ou en majuscules. Ensuite, vous exécutez les différentes requêtes de manière séquentielle.

jbrunodomingues
la source
1
Attention: comment allez-vous diviser cela? insert into books values ('1478355824', 'An Introduction To Programming in Go (paperback)', 9.00)
Blorgbeard sort le
Bon point :-) Ma situation n'avait pas d'inserts de données. Je créais juste des tables, des procédures stockées et des fonctions. Le mot lié était plus utile dans mon cas particulier car il s'occupait également de «aller» en dernière ligne.
jbrunodomingues
0

J'ai rencontré le même problème et je l'ai finalement résolu par un simple remplacement de chaîne, en remplaçant le mot GO par un point-virgule (;)

Tout semble fonctionner correctement lors de l'exécution de scripts avec des commentaires en ligne, des commentaires de bloc et des commandes GO

public static bool ExecuteExternalScript(string filePath)
{
    using (StreamReader file = new StreamReader(filePath))
    using (SqlConnection conn = new SqlConnection(dbConnStr))
    {
        StringBuilder sql = new StringBuilder();

        string line;
        while ((line = file.ReadLine()) != null)
        {
            // replace GO with semi-colon
            if (line == "GO")
                sql.Append(";");
            // remove inline comments
            else if (line.IndexOf("--") > -1)
                sql.AppendFormat(" {0} ", line.Split(new string[] { "--" }, StringSplitOptions.None)[0]);
            // just the line as it is
            else
                sql.AppendFormat(" {0} ", line);
        }
        conn.Open();

        SqlCommand cmd = new SqlCommand(sql.ToString(), conn);
        cmd.ExecuteNonQuery();
    }

    return true;
}
Morvael
la source
1
Cela ne fonctionnera pas pour les commandes DDL, qui doivent être dans leur propre lot. Par exemple, create / alter table et al
Blorgbeard est sorti
De plus, vous semblez supprimer les commentaires sans raison .. Ce qui briserait toutes les chaînes contenant --, par exemple.
Blorgbeard sort
Salut Blorgbeard - SQL Server 2012 semble gérer les instructions DDL OK. Les scripts que j'utilisais devaient me permettre de reconstruire toute une structure de base de données, d'effacer la structure actuelle, de créer des tables, d'ajouter des index, etc. également terminé un lot?
Morvael
De plus, la suppression des commentaires était due au fait que cela produirait une seule ligne de SQL, tout SQL après le commentaire serait donc commenté, mais je prends note de votre point de vue s'il y avait une chaîne qui contenait - ce n'était pas un commentaire.
Morvael
1
Ah ok, il suffit de chercher: "Les instructions CREATE DEFAULT, CREATE FUNCTION, CREATE PROCEDURE, CREATE RULE, CREATE SCHEMA, CREATE TRIGGER et CREATE VIEW ne peuvent pas être combinées avec d'autres instructions dans un lot. L'instruction CREATE doit démarrer le lot. Tout les autres instructions qui suivent dans ce lot seront interprétées comme faisant partie de la définition de la première instruction CREATE. Une table ne peut pas être modifiée, puis les nouvelles colonnes référencées dans le même lot. "
Blorgbeard sort
-1

Pour tous ceux qui ont encore le problème. Vous pouvez utiliser Microsoft SMO officiel

https://docs.microsoft.com/en-us/sql/relational-databases/server-management-objects-smo/overview-smo?view=sql-server-2017

using (var connection = new SqlConnection(connectionString))
{
  var server = new Server(new ServerConnection(connection));
  server.ConnectionContext.ExecuteNonQuery(sql);
}
Sprot
la source
Cela n'ajoute rien au-dessus de la réponse la plus votée et acceptée, ce qui suggère également SMO (publié il y a 10 ans!).
Blorgbeard sort le
-4

Trop difficile :)

Créez un tableau de chaînes str [] en remplaçant GO par ", @":

            string[] str ={
                @"
USE master;
",@"


CREATE DATABASE " +con_str_initdir+ @";
",@"
-- Verify the database files and sizes
--SELECT name, size, size*1.0/128 AS [Size in MBs] 
--SELECT name 
--FROM sys.master_files
--WHERE name = N'" + con_str_initdir + @"';
--GO

USE " + con_str_initdir + @";
",@"

SET ANSI_NULLS ON
",@"
SET QUOTED_IDENTIFIER ON
",@"

IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Customers]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[Customers](
    [CustomerID] [int] IDENTITY(1,1) NOT NULL,
    [CustomerName] [nvarchar](50) NULL,
 CONSTRAINT [PK_Customers] PRIMARY KEY CLUSTERED 
(
    [CustomerID] ASC
)WITH (PAD_INDEX  = OFF, IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
END
",@"



SET ANSI_NULLS ON
",@"
SET QUOTED_IDENTIFIER ON
",@"
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GOODS]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[GOODS](
    [GoodsID] [int] IDENTITY(1,1) NOT NULL,
    [GoodsName] [nvarchar](50) NOT NULL,
    [GoodsPrice] [float] NOT NULL,
 CONSTRAINT [PK_GOODS] PRIMARY KEY CLUSTERED 
(
    [GoodsID] ASC
)WITH (PAD_INDEX  = OFF, IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
END
",@"
SET ANSI_NULLS ON
",@"
SET QUOTED_IDENTIFIER ON
",@"
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Orders]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[Orders](
    [OrderID] [int] IDENTITY(1,1) NOT NULL,
    [CustomerID] [int] NOT NULL,
    [Date] [smalldatetime] NOT NULL,
 CONSTRAINT [PK_Orders] PRIMARY KEY CLUSTERED 
(
    [OrderID] ASC
)WITH (PAD_INDEX  = OFF, IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
END
",@"
SET ANSI_NULLS ON
",@"
SET QUOTED_IDENTIFIER ON
",@"
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[OrderDetails]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[OrderDetails](
    [OrderID] [int] NOT NULL,
    [GoodsID] [int] NOT NULL,
    [Qty] [int] NOT NULL,
    [Price] [float] NOT NULL,
 CONSTRAINT [PK_OrderDetails] PRIMARY KEY CLUSTERED 
(
    [OrderID] ASC,
    [GoodsID] ASC
)WITH (PAD_INDEX  = OFF, IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
END
",@"

SET ANSI_NULLS ON
",@"
SET QUOTED_IDENTIFIER ON
",@"
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[InsertCustomers]') AND type in (N'P', N'PC'))
BEGIN
EXEC dbo.sp_executesql @statement = N'-- =============================================
-- Author:      <Author,,Name>
-- Create date: <Create Date,,>
-- Description: <Description,,>
-- =============================================
create PROCEDURE [dbo].[InsertCustomers]
 @CustomerName nvarchar(50),
 @Identity int OUT
AS
INSERT INTO Customers (CustomerName) VALUES(@CustomerName)
SET @Identity = SCOPE_IDENTITY()

' 
END
",@"
IF NOT EXISTS (SELECT * FROM sys.foreign_keys WHERE object_id = OBJECT_ID(N'[dbo].[FK_Orders_Customers]') AND parent_object_id = OBJECT_ID(N'[dbo].[Orders]'))
ALTER TABLE [dbo].[Orders]  WITH CHECK ADD  CONSTRAINT [FK_Orders_Customers] FOREIGN KEY([CustomerID])
REFERENCES [dbo].[Customers] ([CustomerID])
ON UPDATE CASCADE
",@"
ALTER TABLE [dbo].[Orders] CHECK CONSTRAINT [FK_Orders_Customers]
",@"
IF NOT EXISTS (SELECT * FROM sys.foreign_keys WHERE object_id = OBJECT_ID(N'[dbo].[FK_OrderDetails_GOODS]') AND parent_object_id = OBJECT_ID(N'[dbo].[OrderDetails]'))
ALTER TABLE [dbo].[OrderDetails]  WITH CHECK ADD  CONSTRAINT [FK_OrderDetails_GOODS] FOREIGN KEY([GoodsID])
REFERENCES [dbo].[GOODS] ([GoodsID])
ON UPDATE CASCADE
",@"
ALTER TABLE [dbo].[OrderDetails] CHECK CONSTRAINT [FK_OrderDetails_GOODS]
",@"
IF NOT EXISTS (SELECT * FROM sys.foreign_keys WHERE object_id = OBJECT_ID(N'[dbo].[FK_OrderDetails_Orders]') AND parent_object_id = OBJECT_ID(N'[dbo].[OrderDetails]'))
ALTER TABLE [dbo].[OrderDetails]  WITH CHECK ADD  CONSTRAINT [FK_OrderDetails_Orders] FOREIGN KEY([OrderID])
REFERENCES [dbo].[Orders] ([OrderID])
ON UPDATE CASCADE
ON DELETE CASCADE
",@"
ALTER TABLE [dbo].[OrderDetails] CHECK CONSTRAINT [FK_OrderDetails_Orders]


                "};


            for(int i =0; i<str.Length;i++)     
            {
                myCommand.CommandText=str[i];
                try
                {
                myCommand.ExecuteNonQuery();
                }
                catch (SystemException ee)
                {
                    MessageBox.Show("Error   "+ee.ToString());
                }

            }

C'est tout, profitez-en.

grv
la source