Comment faire pour retourner la table temporaire partir d'une procédure stockée

CREATE PROCEDURE [test].[proc]
@ConfiguredContentId int,
@NumberOfGames int
AS
BEGIN
 SET NOCOUNT ON
 RETURN 
 @WunNumbers TABLE (WinNumb int)

    INSERT INTO @WunNumbers (WinNumb)
 SELECT TOP (@NumberOfGames) WinningNumber
 FROM [Game].[Game] g
 JOIN [Game].[RouletteResult] AS rr ON g.[Id] = rr.[gameId]
 WHERE g.[ConfiguredContentId] = @ConfiguredContentId
 ORDER BY g.[Stoptime] DESC

 SELECT WinNumb, COUNT (WinNumb) AS "Count"
 FROM @WunNumbers wn
 GROUP BY wn.[WinNumb]
END
GO

Cette procédure stockée renvoie les valeurs de la première instruction select, mais je voudrais avoir des valeurs à partir de la deuxième instruction select pour être retourné. Tableau @WunNumbers est une table temporaire.

Des idées???

merci de reformater votre code sql.
Ce code n'est pas valide SQL. Il pourrait être, en cas de "RETOUR @WinNumbers" était "DECLARE @WinNumbers", mais alors le reste a l'air droit de retourner le résultat final définies
je vois maintenant, j'ai posté un code erroné. Il est "DECLARE @WinNumbers" mais ça ne fonctionne toujours pas.

OriginalL'auteur dani | 2009-09-18

6

Quelle version de SQL Server que vous utilisez? Dans SQL Server 2008, vous pouvez utiliser Tableau des Paramètres et Types de Table.

Une approche alternative est de retourner un tableau de variable à partir d'une fonction définie par l'utilisateur, mais je ne suis pas un grand fan de cette méthode.

Vous pouvez trouver un exemple ici

Je suis à l'aide de sql server 2005

OriginalL'auteur
27

Prendre un coup d'oeil à ce code,
```
CREATE PROCEDURE Test

AS
    DECLARE @tab table (no int, name varchar(30))

    insert @tab  select eno,ename from emp  

    select * from @tab
RETURN
```
Comment cela serait-il de retour/sortie une variable de table à l'appelant? Actuellement, il retourne un jeu de résultats.
Elle renvoie le résultat de l'instruction select (vraie question) qui, dans ce cas, se trouve être le contenu de la table locale de la variable @tab.
si je ne EXECUTE Test comment puis-je accéder à la @tab ?
Je suis en train de faire quelque chose de similaire, quand je le lance dans management studio, je vois mon jeu de résultats, mais lorsque je l'exécute à l'aide de ADO.net le SqlReader obtient un jeu de résultats vide.

OriginalL'auteur
3

D'une table temporaire peut être créé à l'appelant et puis remplie à partir de l'appelé SP.
```
  create table #GetValuesOutputTable(
     ...   
  );

  exec GetValues; -- populates #GetValuesOutputTable

  select * from #GetValuesOutputTable;
```
Certains avantages de cette approche au cours de la "insert exec" est qu'il peut être imbriqués et qu'il peut être utilisé comme une entrée ou une sortie.

Certains inconvénients sont que "l'argument" n'est pas publique, la création de la table existe au sein de chaque appelant, et que le nom de la table pourraient entrer en collision avec d'autres temp objets. Il est utile lorsque la temp nom de la table correspond étroitement à la SP nom et suit une convention.

De le prendre un peu plus loin, pour une sortie seulement les tables temporaires, l'insert-exec approche et la table temp approche peut être pris en charge simultanément par le appelé SP. Ce qui n'aide pas trop pour le chaînage de SP est parce que la table doivent encore être définies en l'appelant, mais peut aider à simplifier les tests à partir de la ligne de commande ou lors d'un appel externe.
```
  -- The "called" SP
  declare
      @returnAsSelect bit = 0;

  if object_id('tempdb..#GetValuesOutputTable') is null
  begin
      set @returnAsSelect = 1;
      create table #GetValuesOutputTable(
         ...   
      );
  end

  -- populate the table

  if @returnAsSelect = 1
      select * from #GetValuesOutputTable;
```
OriginalL'auteur
0

Le type de retour d'une procédure est de type int.

Vous pouvez également retourner les ensembles de résultats (en tant que votre code ne le fait actuellement) (bon d'accord, vous pouvez également envoyer des messages, qui sont des chaînes de caractères)

Ceux sont les seuls retours que vous pouvez faire. Alors que vous pouvez ajouter les paramètres de la table à une procédure (voir le FRET), ils sont à l'entrée.

Edit:

(Ou une autre affiche mentionné, vous pourriez aussi utiliser une Fonction à valeur de Table, plutôt que d'une procédure)

OriginalL'auteur
0

OUI, VOUS POUVEZ.

Dans la procédure stockée, vous remplissez le tableau @tbRetour.

À la fin de votre procédure stockée, vous écrivez:
```
SELECT * FROM @tbRetour 
```
Pour exécuter la procédure stockée, vous écrivez:
```
USE [...]
GO

DECLARE @return_value int

EXEC @return_value = [dbo].[getEnregistrementWithDetails]
@id_enregistrement_entete = '(guid)'

GO
```
OriginalL'auteur
0

D'abord créer un véritable, table permanente comme un modèle qui a la nécessaire mise en page pour le retour temporaire de la table, à l'aide d'une convention de nommage qui l'identifie comme un modèle et des liens symboliquement, à la SP, par exemple, tmp_SPName_Output. Ce tableau, ils ne contiennent aucune données.

Dans la SP, utilisez l'accessoire pour charger des données dans une table temporaire en suivant la même convention de nommage, par exemple #SPName_Output qui est supposé exister. Vous pouvez tester son existence et de retourner une erreur si elle ne le fait pas.

Avant l'appel de la sp utiliser cette sélection simple pour créer la table temp:
```
SELECT TOP(0) * INTO #SPName_Output FROM tmp_SPName_Output;
EXEC SPName;
-- Now process records in #SPName_Output;
```
Ce a ces avantages distincts:
- La table temporaire locale pour la session en cours, à la différence ##, donc seront pas en conflit avec des appels simultanés à la SP à partir de
  différentes sessions. Il est également supprimée automatiquement lorsque vous êtes hors de portée.
- Le modèle de table est maintenue à côté de la SP, donc si des modifications sont
  fait à la sortie (les nouvelles colonnes sont ajoutées, par exemple), puis pré-existant
  les appelants de la SP ne se cassent pas. L'appelant n'a pas besoin d'être changé.
- Vous pouvez définir n'importe quel nombre de tables de sortie avec des appellations différentes pour
  un SP et les remplir tous. Vous pouvez également définir différentes sorties
  avec des appellations différentes et ont la SP vérifier l'existence de la temp
  les tables pour voir qui doivent être remplis.
- De même, si des changements majeurs sont apportés, mais que vous souhaitez conserver vers l'arrière
  de compatibilité, vous pouvez avoir un nouveau modèle de table et les noms de la plus tard
  version mais toujours en faveur de la version antérieure par la vérification qui a temp
  le tableau que l'appelant a créé.
OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.