Mise à jour SQL où dans l'ensemble de données

+------------------+
| id1 | id2 | bool |
+------------------+
|  1  |  1  |  F   |
|  1  |  2  |  F   |
|  2  |  1  |  F   |
+------------------+

UPDATE table_name
SET bool = T
WHERE (id1, id2) IN ((1,1),(2,1)) --Need work here

Donc, fondamentalement, je veux sélectionner l'emplacement où les conditions de (id1, id2) = (valeur1, valeur2).
Similaire à l'instruction ci-dessous:

WHERE id1 = value1 AND id2 = value2

cependant dans un ensemble de valeurs dans un tableau.
Est-ce possible?

Merci d'avance

EDIT: je suis à l'aide de SQL server 2008. Je suis désolé si ce n'était pas trop clair.
Je suis en train de mettre cela en tant que procédure stockée et l'appeler à partir d'un service. L'entrée serait une sorte d'un tableau (de taille variable), et de trouver une correspondance avec les deux Id en ligne.

source d'informationauteur Yuan Sunarto

2

Ici est la façon de le faire dans MSSql. Tous vous avez besoin est de faire une seule valeur (dans cet exemple de type VARCHAR) à partir de Id1 et Id2. Dans ce cas, vous pouvez utiliser DE l'état avec les valeurs définies. Aussi, vous devriez réfléchir sur les valeurs Null dans les id1 et id2, s'ils sont autorisés dans ces domaines (juste ajouter: and id1 is not null and id2 is not null).
```
UPDATE table_name
SET bool = T
WHERE convert(varchar(20),id1)+','+convert(varchar(20),id2) in ('1,1','2,1')
```

Une idée d'y parvenir est de faire usage de la table temporaire

Create Table #Temp
(
  id1 int,
  id2 int
)
insert into #Temp values(1,1)
insert into #Temp values(1,2)
insert into #Temp values(2,1)
insert into #Temp values(2,2)

--update data
UPDATE 
table_name 
SET bool = T 
from table_name T1   
inner join #Temp T2 
on T1.Id1= T2.Id1
and T1.Id2= T2.Id2

Essayer Ce - Version de SQL Server 2008.

create table mytable
(
id1 int,
id2 int,
bool char(1)
);

insert INTO mytable VALUES(1,1,'F');
insert INTO mytable VALUES(1,2,'F');
insert INTO mytable VALUES(2,1,'F');

SELECT * FROM mytable;

update mytable 
set bool='T'
WHERE exists (SELECT id1,id2 from mytable tb2
where mytable.id1 = 1 AND mytable.id2 = 1
or mytable.id1 = 2 AND mytable.id2 = 1);

SELECT * from mytable;

Cette requête fonctionne dans oracle...

UPDATE table_name 
SET BOOL = T 
WHERE (id1, id2) IN (SELECT 1,1 FROM DUAL UNION SELECT 2,1  FROM DUAL);

Qui est votre base de données?

0

Ce que vous êtes fondamentalement essaie de faire? Pourquoi est-ce la façon dont vous avez choisi de le faire? Il semble que vous êtes un peu floue dans la compréhension de base de jeu de logique. Chacune des réponses fournies par d'autres affiches sont valides et de travail, mais peut-être pas le plus adapté pour votre but. Est-ce le traitement contre un jeu de données? Fait-il partie d'un chargement de données ou d'insertion? Chacun des champs de l'IDENTIFIANT que vous avez énumérés, a sa propre gamme de valeurs uniques. Basé sur votre exemple, il semble que ce que vous êtes vraiment vouloir faire est de mettre à jour la valeur booléenne quand ID2 = 1
```
UPDATE table_name SET Bool = 'T'
WHERE Id2 = 1
```
Plus probable que vous êtes désireux de développer une logique qui définit la valeur Booléenne basés sur les données de la règle, si par exemple, Id2 est inférieur ou égal à Id1. Un cas de déclaration de travaux ici:
```
UPDATE table_name SET Bool = CASE WHEN Id1 > Id2 THEN 'T' ELSE 'F' END
```
C'est beaucoup plus efficace lorsque vous traitez avec de grands ensembles de données que l'écriture ET/OU des règles dans votre clause where pour chaque variation de valeurs à insérer.

Penser à OÙ comme un filtre plutôt que comme un endroit pour mettre en œuvre si/alors logique de type.

Dans les petites insérer des données (vous soit manuellement, tapez des valeurs dans les champs de la table, sont l'insertion d'une sorte de formulaire web transaction par transaction), il est probablement plus simple juste pour définir manuellement la valeur que vous voyez l'ajustement, ou de construire que dans la partie procédure de votre système et d'appliquer une règle de validation à la table.

Si vous voulez écrire une procédure stockée qui est-ce à vous de créer des variables pour les valeurs d'ID et de les relier jusqu'à ce que le système transmet les informations externes dans votre système de base de données. (Je présume que vous avez créé la table des structures déjà);
```
CREATE PROCEDURE table_name_insert
@Id1 Int NOT NULL,
@Id2 Int NOT NULL

-- If you want to execute the logic outside of the DB environment
-- (perhaps as part of an SSIS package) then you will want to add this
-- variable and pass it in explicitly.

, @Bool bit NOT NULL 


AS

DECLARE @sql nvarchar(4000)


SET @sql = '
INSERT INTO table_name (ID1, ID2, Bool)
SELECT @Id1, @Id2, [Case Logic or Variable Value for Bool]
' EXEC sp_executeSQL @sql
```
Ce processus peut être appelé par votre programme et vous passer les variables vous pouvez générer à partir d'un tableau. Il y a aussi des façons où vous pouvez importer directement les valeurs de la colonne appropriée, puis d'exécuter le Bool logique dans l'après-insérer le code. "Codage en dur" une OÙ la déclaration de traiter chaque cas est inefficace, et une mauvaise habitude à prendre.

si vous utilisez SQL Server essayer cette

     UPDATE table_name
     SET bool = T
     WHERE (convert(varchar 20, id1) + '-' + convert(varchar 20 , id2)) 
      IN (convert(varchar 20 , value1) + '-' + convert(varchar 20 , value2),
        convert(varchar 20 , value3) + '-' + convert(varchar 20 , value4));

essayer si vous utilisez oracle

     UPDATE table_name
     SET bool = T
       WHERE (id1 || '-' || id2) IN (value1 || '-' || value2)

habituellement, nous utilisons dans la clause si nous avons plus qu'une valeur de match.
en supposant que vous (id1 = valeur1 et id2 =valeur2) et (id1 = valeur3 et id2 =value4)

     UPDATE table_name
     SET bool = T
     WHERE (id1 || '-' || id2) IN (value1 || '-' || value2, value3 || '-' || value4)

Vous pouvez envoyer votre liste de valeurs à la procédure stockée au format XML. Décompresser le fichier XML de la table variable et utiliser exists pour trouver les lignes que vous devez mettre à jour.

create procedure YourSP
  @XMLParam xml
as

declare @T table(id1 int, id2 int)

insert into @T(id1, id2)
select T.N.value('id1[1]', 'int'),
       T.N.value('id2[1]', 'int')
from @XMLParam.nodes('/Row') as T(N)

update table_name
set bool = 'T'
where exists (select *
              from @T as T
              where T.id1 = table_name.id1 and
                    T.id2 = table_name.id2)

Appeler comme ceci:

exec YourSP '<Row>
               <id1>1</id1>
               <id2>1</id2>
             </Row>
             <Row>
               <id1>2</id1>
               <id2>1</id2>
             </Row>'

Vous devez vous connecter pour publier un commentaire.