Comment insérer une chaîne de caractères ( ' ) dans la base de données sql?

J'ai les cordes, qui se compose de ( ' ) guillemet comme "amour de la mère" ...

Tout en insérant les données par des requêtes sql à partir de c#. Il indique une erreur. Comment puis-je résoudre le problème et d'insérer ce type de données avec succès?

string str2 = "Insert into tblDesEmpOthDetails (EmpID, Interviewnotes) values ('" + EmpId + "','" + Interviewnotes + "')";

Notes d'entrevue consiste en la valeur comme "amour de la Mère" (avec des guillemets simples). Lors de l'exécution de cette requête, il affiche le message d'erreur "Ouvrez les guillemets après la chaîne de caractères ')" comment puis-je insérer ce type de cordes?

montrer un peu de code s'il vous plaît.
Il n'y a pas une telle chose comme un base de données SQL -- SQL est juste le Structured Query Language, une langue utilisée par de nombreux systèmes de base de données, mais pas un produit de base de données... Nous avons vraiment besoin de savoir ce système de base de données (et quelle version) que vous utilisez....
MS sql est ma base de données
dans ce cas, je pense que nous pouvons conclure que l'OP est d'utiliser la concaténation pour former des requêtes, auquel cas le ' à '' astuce est probablement assez d'informations pour être dangereux. Paramètres sont les correct réponse ici.

OriginalL'auteur Arun Kumar | 2012-06-20

c#sql-server

22

Je suis sûr que vous n'utilisez pas les paramètres SQL:
```
using (SqlCommand myCommand = new SqlCommand(
    "INSERT INTO table (text1, text2) VALUES (@text1, @text2)")) {

    myCommand.Parameters.AddWithValue("@text1", "mother's love");
    myCommand.Parameters.AddWithValue("@text2", "father's love");
    //...

    myConnection.Open();
    myCommand.ExecuteNonQuery();
    //...
}
```
Merci beaucoup pour votre réponse correcte et aussi une excellente réponse.
Sera-ce code fonctionne: command.Parameters.AddWithValue("@codes", "'A','B','C'");
faut-il essayer et poser une nouvelle question sur DONC si il ne fonctionne pas comme vous l'attendez) Oui, je ne vois pas pourquoi cela ne fonctionne pas.
Merci. Je vais poster une question à ce sujet.
À partir de ce post j'ai trouvé ma réponse.

OriginalL'auteur Otiel

Utiliser des paramètres nommés et les SqlParameter.

De http://www.dotnetperls.com/sqlparameter

class Program
{
    static void Main()
    {
        string dogName = "Fido";  //The name we are trying to match.

        //Use preset string for connection and open it.
        string connectionString = 
            ConsoleApplication1.Properties.Settings.Default.ConnectionString;

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            //Description of SQL command:
            //1. It selects all cells from rows matching the name.
            //2. It uses LIKE operator because Name is a Text field.
            //3. @Name must be added as a new SqlParameter.
            using (SqlCommand command = 
               new SqlCommand("SELECT * FROM Dogs1 WHERE Name LIKE @Name", connection))
            {
                //Add new SqlParameter to the command.
                command.Parameters.Add(new SqlParameter("Name", dogName));

                //Read in the SELECT results.
                SqlDataReader reader = command.ExecuteReader();
                while (reader.Read())
                {
                    int weight = reader.GetInt32(0);
                    string name = reader.GetString(1);
                    string breed = reader.GetString(2);
                    Console.WriteLine("Weight = {0}, Name = {1}, Breed = {2}", weight, name, breed);
                }
            }
        }
    }
}

Downvoter, le soin de l'expliquer?

OriginalL'auteur Andy

6

Bien que, vous pouvez remplacer tous les caractères dans la chaîne de deux caractères ' ( " ), ce n'est pas une bonne idée. En raison de cette question, et beaucoup d'autres raisons (comme le fait d'éviter les attaques par injection SQL), vous devriez être en utilisant des paramètres nommés plutôt que d'ajouter de la valeur à vos instruction insert en concaténant directement dans la chaîne. Par exemple:
```
command.CommandText = "Insert into tblDesEmpOthDetails (EmpID, Interviewnotes) values (@EmpId, @Interviewnotes)";
command.Parameters.AddWithValue("EmpId", EmpId);
command.Parameters.AddWithValue("Interviewnotes", Interviewnotes);
```
OriginalL'auteur Steven Doggart
2

Ajoutez cette ligne à une chaîne de votre tentative de saisie

vous dire de chaîne a été
```
string test = "that's not working correctly"
test = replace(Request.QueryString(test), "'", "''")
```
puis test est maintenant
```
"that''s not working correctly"
```
qui est syntaxiquement correct pour SQL

Ce qui concerne

C'est techniquement réalisable, mais l'enseignement est une mauvaise pratique. Le correct approche ici est d'utiliser les paramètres. Tout le reste est tout simplement dangereux.
Bien que cette adresse de l'auteur du problème que j'ai à downvote pour être une idée horrible.
Downvoted; alors qu'elle n'en résout ce problème particulier, il laisse ouvert encore plus grand.

OriginalL'auteur Eric Robinson
2

Comme une variante sur les réponses (très bien) point vous à paramètres: si cela vous semble beaucoup de travail, alors éviter avec un outil tel que dapper:
```
int empId = 123;
string notes = "abc";
connection.Execute(@"insert into tblDesEmpOthDetails (EmpID, Interviewnotes)
                     values (@empId, @notes)", new {empId, notes});
```
Dapper prendra automatiquement la empId et notes (à partir de l'objet anonyme) et de les ajouter nommé/paramètres typés. L'similaires Query/Query<T> extension-méthodes permettent aussi facile et hautement optimisé interrogation directement dans un modèle objet.

OriginalL'auteur Marc Gravell
0

Vous avez besoin pour utiliser double "
```
INSERT INTO something (Name) VALUES ('O''something''s')
```
Cela permettra d'insérer O'something.
Un autre exemple, j'ai lu est:

Permet de supposer que nous avons une chaîne:
```
SQL = "SELECT * FROM name WHERE LastName='" & LastName & "' "
```
et si nous avons lastname quelque chose comme O'Brian, O'Reily etc. nous avons obtenu de la chaîne comme
```
SELECT * FROM name WHERE LastName='O'Brien'
```
la deuxième " ce sera la fin de l'instruction SQL. Donc la solution la plus simple consiste à utiliser une double " ensuite, nous allons avoir de la chaîne comme ceci:
```
SELECT * FROM name WHERE LastName='O''Brien'
```
C'est techniquement réalisable, mais l'enseignement est une mauvaise pratique. Le correct approche ici est d'utiliser les paramètres. Tout le reste est tout simplement dangereux.
Oui, j'ai entendu parler de ça. Je viens d'écrire ce simple examen pour expliquer double ".
Si vous allez à l'effort de la rendre plus claire cette méthode ne doit PAS être utilisé et expliquer la bonne façon de le faire, je vais enlever mon downvote.

OriginalL'auteur Jason Paddle
0

C'est simple. Vous utilisez la barre oblique inverse: "\". Par exemple:

"amour de la mère" doit être inséré en tant que "mère de l\'amour".

Je l'ai fait un nombre incalculable de fois avec mon propre site web.

OriginalL'auteur William Hou

Vous devez vous connecter pour publier un commentaire.