Méthode simple pour obtenir par programme toutes les procédures stockées

Question

Existe-t-il un moyen d'obtenir des procédures stockées à partir d'une base de données SQL Server 2005 Express à l'aide de C#? Je voudrais exporter toutes ces données de la même manière que vous pouvez le script en utilisant SQL Server Management Studio, sans avoir à installer l'interface graphique.

J'ai vu quelques références à faire quelque chose via le PowerShell, mais à la fin, une application console C# est ce que je veux vraiment.

Pour clarifier ....

Je voudrais scripter les procédures stockées. La liste via le Select * from sys.procedures est utile, mais à la fin j'ai besoin de script chacun d'eux.

Answer 1

Il suffit de lire la sortie NOM SELECT de SYS.PROCEDURES, puis appelez EXEC sp_helptext SPNAME pour chaque procédure stockée, vous obtiendrez un record avec une ligne de texte par ligne.

Answer 2

This blog post recommande d'exécuter cette contre votre base de données:

select * from sys.procedures 

Answer 3

Vous pouvez écrire du code C# pour exécuter la requête suivante sur la base de données.

Select * from sys.procedures 

Answer 4

Je pense que c'est ce que vous cherchez vraiment:

select SPECIFIC_NAME,ROUTINE_DEFINITION from information_schema.routines 

Il y a une tonne d'autres colonnes utiles là aussi ...

Answer 5

Vous pouvez utiliser SMO pour cela. Tout d'abord, ajouter des références à ces assemblées à votre projet:

• Microsoft.SqlServer.ConnectionInfo
• Microsoft.SqlServer.Smo
• Microsoft.SqlServer.SmoEnum

Ils sont situés dans le GAC (accédez au dossier C: \ WINDOWS \ assembly).

Utilisez le code suivant comme un exemple de procédures stockées de script:

using System; 
using System.Collections.Generic; 
using System.Data; 
using Microsoft.SqlServer.Management.Smo; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Server server = new Server(@".\SQLEXPRESS"); 
     Database db = server.Databases["Northwind"]; 
     List<SqlSmoObject> list = new List<SqlSmoObject>(); 
     DataTable dataTable = db.EnumObjects(DatabaseObjectTypes.StoredProcedure); 
     foreach (DataRow row in dataTable.Rows) 
     { 
     string sSchema = (string)row["Schema"]; 
     if (sSchema == "sys" || sSchema == "INFORMATION_SCHEMA") 
      continue; 
     StoredProcedure sp = (StoredProcedure)server.GetSmoObject(
      new Urn((string)row["Urn"])); 
     if (!sp.IsSystemObject) 
      list.Add(sp); 
     } 
     Scripter scripter = new Scripter(); 
     scripter.Server = server; 
     scripter.Options.IncludeHeaders = true; 
     scripter.Options.SchemaQualify = true; 
     scripter.Options.ToFileOnly = true; 
     scripter.Options.FileName = @"C:\StoredProcedures.sql"; 
     scripter.Script(list.ToArray()); 
    } 
} 

Voir aussi: SQL Server: SMO Scripting Basics.

Answer 6

;WITH ROUTINES AS (
    -- CANNOT use INFORMATION_SCHEMA.ROUTINES because of 4000 character limit 
    SELECT o.type_desc AS ROUTINE_TYPE 
      ,o.[name] AS ROUTINE_NAME 
      ,m.definition AS ROUTINE_DEFINITION 
    FROM sys.sql_modules AS m 
    INNER JOIN sys.objects AS o 
     ON m.object_id = o.object_id 
) 
SELECT * 
FROM ROUTINES 

Answer 7

Vous pouvez utiliser:

DataTable dtProcs = sqlConn.GetSchema("Procedures", new string[] { databaseName }); 
DataTable dtProcParams = sqlConn.GetSchema("ProcedureParameters", new string[] { databaseName }); 

Vous pouvez également obtenir toutes sortes d'autres informations de schéma comme les tables, les index, etc. si vous en avez besoin.

Vous pouvez obtenir des informations sur GetSchema() here et informations sur les collections de schéma SQL Server here

Edit: Désolé, cela ne fonctionne pas avec les scripts en fait l'info, mais je suppose qu'il est d'info utile d'avoir.

Answer 8

begin 
--select column_name from INFORMATION_SCHEMA.COLUMNS where TABLE_NAME='Products' 
--Declare the Table variable 
DECLARE @GeneratedStoredProcedures TABLE 
(
     Number INT IDENTITY(1,1), --Auto incrementing Identity column 
     name VARCHAR(300) --The string value 
) 

--Decalre a variable to remember the position of the current delimiter 
DECLARE @CurrentDelimiterPositionVar INT 
declare @sqlCode varchar(max) 
--Decalre a variable to remember the number of rows in the table 
DECLARE @Count INT 

--Populate the TABLE variable using some logic 
INSERT INTO @GeneratedStoredProcedures SELECT name FROM sys.procedures where name like 'procGen_%' 

--Initialize the looper variable 
SET @CurrentDelimiterPositionVar = 1 

--Determine the number of rows in the Table 
SELECT @Count=max(Number) from @GeneratedStoredProcedures 

--A variable to hold the currently selected value from the table 
DECLARE @CurrentValue varchar(300); 

--Loop through until all row processing is done 
WHILE @CurrentDelimiterPositionVar <= @Count 
BEGIN 
    --Load current value from the Table 
    SELECT @CurrentValue = name FROM @GeneratedStoredProcedures WHERE Number = @CurrentDelimiterPositionVar 
    --Process the current value 
    --print @CurrentValue 
    set @sqlCode = 'drop procedure ' + @CurrentValue 
    print @sqlCode 
    --exec (@sqlCode) 


    --Increment loop counter 
    SET @CurrentDelimiterPositionVar = @CurrentDelimiterPositionVar + 1; 
END 

end 

Answer 9

Si vous ouvrez une boîte de réflecteur sur SqlMetal.exe (une partie autonome de LINQ to SQL qui génère du code à partir d'une base de données), vous pouvez voir les instructions SQL qu'il utilise pour obtenir un liste de toutes les procédures et fonctions stockées. Le SQL est similaire, mais pas identique, à the one in this answer.

Answer 10

public static void GenerateTableScript() 
    { 
     Server databaseServer = default(Server);//DataBase Server Name 
     databaseServer = new Server("yourDatabase Server Name"); 
     string strFileName = @"C:\Images\Your FileName_" + DateTime.Today.ToString("yyyyMMdd") + ".sql"; //20120720`enter code here 
     if (System.IO.File.Exists(strFileName)) 
      System.IO.File.Delete(strFileName); 
     List<SqlSmoObject> list = new List<SqlSmoObject>(); 
     Scripter scripter = new Scripter(databaseServer); 
     Database dbUltimateSurvey = databaseServer.Databases["YourDataBaseName"];//DataBase Name 
     //Table scripting Writing 
     DataTable dataTable1 = dbUltimateSurvey.EnumObjects(DatabaseObjectTypes.Table); 
     foreach (DataRow drTable in dataTable1.Rows) 
     { 
      //string strTableSchema = (string)drTable["Schema"]; 
      //if (strTableSchema == "dbo") 
      // continue; 
      Table dbTable = (Table)databaseServer.GetSmoObject(new Urn((string)drTable["Urn"])); 
      if (!dbTable.IsSystemObject) 
       if (dbTable.Name.Contains("SASTool_")) 
        list.Add(dbTable); 
     } 
     scripter.Server = databaseServer; 
     scripter.Options.IncludeHeaders = true; 
     scripter.Options.SchemaQualify = true; 
     scripter.Options.ToFileOnly = true; 
     scripter.Options.FileName = strFileName; 
     scripter.Options.DriAll = true; 
     scripter.Options.AppendToFile = true; 
     scripter.Script(list.ToArray());//Table Script completed 
     //Store Procedures scripting Writing 
     list = new List<SqlSmoObject>(); 
     DataTable dataTable = dbUltimateSurvey.EnumObjects(DatabaseObjectTypes.StoredProcedure); 
     foreach (DataRow row in dataTable.Rows) 
     { 
      string sSchema = (string)row["Schema"]; 
      if (sSchema == "sys" || sSchema == "INFORMATION_SCHEMA") 
       continue; 
      StoredProcedure sp = (StoredProcedure)databaseServer.GetSmoObject(
       new Urn((string)row["Urn"])); 
      if (!sp.IsSystemObject) 
       if (sp.Name.Contains("custom_")) 
        list.Add(sp); 
     } 
     scripter.Server = databaseServer; 
     scripter.Options.IncludeHeaders = true; 
     scripter.Options.SchemaQualify = true; 
     scripter.Options.ToFileOnly = true; 
     scripter.Options.FileName = strFileName; 
     scripter.Options.DriAll = true; 
     scripter.Options.AppendToFile = true; 
     scripter.Script(list.ToArray()); // Stored procedure Script completed 
    } 

Answer 11

En supposant que vous avez SqlConnection objet appelé sqlCon, moyen le plus simple est d'appeler sqlCon.GetSchema ("procédures")

Answer 12

C'est un SQL que je viens testé et utilisé dans MSSQL

SELECT NAME from SYS.PROCEDURES 
order by name 

Dans le cas où vous avez besoin de chercher un nom spécifique ou sous-chaîne/texte

SELECT NAME from SYS.PROCEDURES 
where name like '%<TEXT_TO_LOOK_FOR>%' 
order by name 

Remplacer exactement que par exemple:

SELECT NAME from SYS.PROCEDURES 
where name like '%CUSTOMER%' 
order by name 

Et appeler

EXEC sp_HelpText SPNAME 

pour chaque procédure stockée, vous obtiendrez un jeu d'enregistrements avec une ligne de texte par ligne