Was kann ich meine SQLite Verbindungszeichenfolge

Question

Ich arbeite mit SQLite zum ersten Mal und jetzt tun, um zu beheben, wenn ich etwas zu dem DB hinzufügen mag, wirft es eine Fehlermeldung,:

"Invalid Connectionstring-Format kann nicht analysieren: String-Wert zu spalten nicht null sein kann“

Hier ist mein Code für diese so weit ist (ich aus einem Tutorial arbeite):

String dbConnection; 

    /// <summary> 
    ///  Default Constructor for SQLiteDatabase Class. 
    /// </summary> 
    public void SQLiteDatabase() 
    { 
     dbConnection = "Data Source = StockDB.s3db; Version = 3;"; 

    } 

public int ExecuteNonQuery(string sql) 
    { 
     SQLiteConnection cnn = new SQLiteConnection(dbConnection); 
     cnn.Open(); //error thrown here 
     SQLiteCommand mycommand = new SQLiteCommand(cnn); 
     mycommand.CommandText = sql; 
     int rowsUpdated = mycommand.ExecuteNonQuery(); 
     cnn.Close(); 
     return rowsUpdated; 
    } 

ich weiß nicht, ob Sie den Code für die sQL-Abfrage benötigen aswell aber:

DBHelper db = new DBHelper(); 
UserInfo UI = new UserInfo(); 
UI.UserName = "henry"; 
UI.Code = 123; 
UI.Role = "LEADER";  
string sql = "INSERT INTO User (Username, Code, Role)" + 
        "VALUES (" + UI.UserName + "" + UI.Code.ToString() + "" + UI.Role + ")"; 
     db.ExecuteNonQuery(sql); 

Ich weiß nicht, wie das zu beheben ist. Ich kann von der Datenbank kein Problem lesen.

Zusätzliche Informationen:

namespace Stock_A_Lot 
{ 
public class DBHelper 
{ 

    String dbConnection; 
    /// <summary> 
    ///  Default Constructor for SQLiteDatabase Class. 
    /// </summary> 
    public void SQLiteDatabase() 
    { 
     dbConnection = "Data Source = StockDB.s3db; Version = 3;"; 
    }  
    public DataTable GetDataTable(string sql) 
    { 
     DataTable dt = new DataTable(); 
     try 
     { 
      SQLiteConnection cnn = new SQLiteConnection(dbConnection); 
      cnn.Open(); 
      SQLiteCommand mycommand = new SQLiteCommand(cnn); 
      mycommand.CommandText = sql; 
      SQLiteDataReader reader = mycommand.ExecuteReader(); 
      dt.Load(reader); 
      reader.Close(); 
      cnn.Close(); 
     } 
     catch (Exception e) 
     { 
      throw new Exception(e.Message); 
     } 
     return dt; 
    } 
    /// <summary> 
    ///  Allows the programmer to interact with the database for purposes other than a query. 
    /// </summary> 
    /// <param name="sql">The SQL to be run.</param> 
    /// <returns>An Integer containing the number of rows updated.</returns> 
    public int ExecuteNonQuery(string sql) 
    { 
     SQLiteConnection cnn = new SQLiteConnection(dbConnection); 
     cnn.Open(); 
     SQLiteCommand mycommand = new SQLiteCommand(cnn); 
     mycommand.CommandText = sql; 
     int rowsUpdated = mycommand.ExecuteNonQuery(); 
     cnn.Close(); 
     return rowsUpdated; 
    } 

    /// <summary> 
    ///  Allows the programmer to retrieve single items from the DB. 
    /// </summary> 
    /// <param name="sql">The query to run.</param> 
    /// <returns>A string.</returns> 
    public string ExecuteScalar(string sql) 
    { 
     SQLiteConnection cnn = new SQLiteConnection(dbConnection); 
     cnn.Open(); 
     SQLiteCommand mycommand = new SQLiteCommand(cnn); 
     mycommand.CommandText = sql; 
     object value = mycommand.ExecuteScalar(); 
     cnn.Close(); 
     if (value != null) 
     { 
      return value.ToString(); 
     } 
     return ""; 
    }   

    /// <summary> 
    ///  Allows the programmer to easily insert into the DB 
    /// </summary> 
    /// <param name="tableName">The table into which we insert the data.</param> 
    /// <param name="data">A dictionary containing the column names and data for the insert.</param> 
    /// <returns>A boolean true or false to signify success or failure.</returns> 
    public bool Insert(String tableName, Dictionary<String, String> data) 
    { 
     String columns = ""; 
     String values = ""; 
     Boolean returnCode = true; 
     foreach (KeyValuePair<String, String> val in data) 
     { 
      columns += String.Format(" {0},", val.Key.ToString()); 
      values += String.Format(" '{0}',", val.Value); 
     } 
     columns = columns.Substring(0, columns.Length - 1); 
     values = values.Substring(0, values.Length - 1); 
     try 
     { 
      this.ExecuteNonQuery(String.Format("insert into {0}({1}) values({2});", tableName, columns, values)); 
     } 
     catch (Exception fail) 
     { 
      MessageBox.Show(fail.Message); 
      returnCode = false; 
     } 
     return returnCode; 
    } 
} 

}

Answer 1

Die Verbindungszeichenfolge könnte in Ordnung sein, aber es wird nie gesetzt wird. Weil Sie nie die SQLiteDatabase() Funktion aufrufen, um es einzustellen.

Es sieht so aus, als ob Sie dafür gedacht sind, ein Konstruktor, nicht eine aufrufbare Methode. Etwas wie folgt aus:

public SQLiteDatabase() 
{ 
    dbConnection = "Data Source = StockDB.s3db; Version = 3;"; 
} 

(Beachten Sie das Fehlen des void Schlüsselwort.)

Oder vielleicht dies:

public DBHelper() 
{ 
    dbConnection = "Data Source = StockDB.s3db; Version = 3;"; 
} 

Hängt davon ab, was die Klasse tatsächlich gestattet.

---

Hinweis: Es ist auch erwähnenswert, dass Ihr Code derzeit für SQL-Injection-Angriffe offen ist. Sie sollten sich parametrisierte Abfragen ansehen, anstatt solche Werte direkt zu verketten. Derzeit erlauben Sie Benutzern möglicherweise, beliebigen Code auf Ihrer Datenbank auszuführen, was sehr schlecht ist. Abfrageparameter behandeln eine solche Eingabe als Werte statt als ausführbaren Code.

Answer 2

versuchen diese

dbConnection = "Data Source = StockDB.db3;"; 

Answer 3

Dies ist, was die Klasse wie um schaut zu arbeiten.

namespace Stock_A_Lot 
{ 
public class DBHelper 
{ 

    String dbConnection; 
    /// <summary> 
    ///  Default Constructor for DBHelper Class. 
    /// </summary> 
    public DBHelper() 
    { 
     dbConnection = "Data Source = StockDB.s3db; Version = 3;"; 
    } 

    /// 
    /* /// <summary> 
    ///  Single Param Constructor for specifying the DB file. 
    /// </summary> 
    /// <param name="inputFile">The File containing the DB</param> 
    public void SQLiteDatabase(String inputFile) 
    { 
     dbConnection = String.Format("Data Source={0}", inputFile); 
    } 

    /// <summary> 
    ///  Single Param Constructor for specifying advanced connection options. 
    /// </summary> 
    /// <param name="connectionOpts">A dictionary containing all desired options and their values</param> 
    public void SQLiteDatabase(Dictionary<String, String> connectionOpts) 
    { 
     String str = ""; 
     foreach (KeyValuePair<String, String> row in connectionOpts) 
     { 
      str += String.Format("{0}={1}; ", row.Key, row.Value); 
     } 
     str = str.Trim().Substring(0, str.Length - 1); 
     dbConnection = str; 
    }*/ 

    /// <summary> 
    ///  Allows the programmer to run a query against the Database. 
    /// </summary> 
    /// <param name="sql">The SQL to run</param> 
    /// <returns>A DataTable containing the result set.</returns> 
    public DataTable GetDataTable(string sql) 
    { 
     DataTable dt = new DataTable(); 
     try 
     { 
      SQLiteConnection cnn = new SQLiteConnection(dbConnection); 
      cnn.Open(); 
      SQLiteCommand mycommand = new SQLiteCommand(cnn); 
      mycommand.CommandText = sql; 
      SQLiteDataReader reader = mycommand.ExecuteReader(); 
      dt.Load(reader); 
      reader.Close(); 
      cnn.Close(); 
     } 
     catch (Exception e) 
     { 
      throw new Exception(e.Message); 
     } 
     return dt; 
    } 
    /// <summary> 
    ///  Allows the programmer to interact with the database for purposes other than a query. 
    /// </summary> 
    /// <param name="sql">The SQL to be run.</param> 
    /// <returns>An Integer containing the number of rows updated.</returns> 
    public int ExecuteNonQuery(string sql) 
    { 
     SQLiteConnection cnn = new SQLiteConnection(dbConnection); 
     cnn.Open(); 
     SQLiteCommand mycommand = new SQLiteCommand(cnn); 
     mycommand.CommandText = sql; 
     int rowsUpdated = mycommand.ExecuteNonQuery(); 
     cnn.Close(); 
     return rowsUpdated; 
    } 

    /// <summary> 
    ///  Allows the programmer to retrieve single items from the DB. 
    /// </summary> 
    /// <param name="sql">The query to run.</param> 
    /// <returns>A string.</returns> 
    public string ExecuteScalar(string sql) 
    { 
     SQLiteConnection cnn = new SQLiteConnection(dbConnection); 
     cnn.Open(); 
     SQLiteCommand mycommand = new SQLiteCommand(cnn); 
     mycommand.CommandText = sql; 
     object value = mycommand.ExecuteScalar(); 
     cnn.Close(); 
     if (value != null) 
     { 
      return value.ToString(); 
     } 
     return ""; 
    } 

    /// <summary> 
    ///  Allows the programmer to easily update rows in the DB. 
    /// </summary> 
    /// <param name="tableName">The table to update.</param> 
    /// <param name="data">A dictionary containing Column names and their new values.</param> 
    /// <param name="where">The where clause for the update statement.</param> 
    /// <returns>A boolean true or false to signify success or failure.</returns> 
    public bool Update(String tableName, Dictionary<String, String> data, String where) 
    { 
     String vals = ""; 
     Boolean returnCode = true; 
     if (data.Count >= 1) 
     { 
      foreach (KeyValuePair<String, String> val in data) 
      { 
       vals += String.Format(" {0} = '{1}',", val.Key.ToString(), val.Value.ToString()); 
      } 
      vals = vals.Substring(0, vals.Length - 1); 
     } 
     try 
     { 
      this.ExecuteNonQuery(String.Format("update {0} set {1} where {2};", tableName, vals, where)); 
     } 
     catch 
     { 
      returnCode = false; 
     } 
     return returnCode; 
    } 

    /// <summary> 
    ///  Allows the programmer to easily delete rows from the DB. 
    /// </summary> 
    /// <param name="tableName">The table from which to delete.</param> 
    /// <param name="where">The where clause for the delete.</param> 
    /// <returns>A boolean true or false to signify success or failure.</returns> 
    public bool Delete(String tableName, String where) 
    { 
     Boolean returnCode = true; 
     try 
     { 
      this.ExecuteNonQuery(String.Format("delete from {0} where {1};", tableName, where)); 
     } 
     catch (Exception fail) 
     { 
      MessageBox.Show(fail.Message); 
      returnCode = false; 
     } 
     return returnCode; 
    } 

    /// <summary> 
    ///  Allows the programmer to easily insert into the DB 
    /// </summary> 
    /// <param name="tableName">The table into which we insert the data.</param> 
    /// <param name="data">A dictionary containing the column names and data for the insert.</param> 
    /// <returns>A boolean true or false to signify success or failure.</returns> 
    public bool Insert(String tableName, Dictionary<String, String> data) 
    { 
     String columns = ""; 
     String values = ""; 
     Boolean returnCode = true; 
     foreach (KeyValuePair<String, String> val in data) 
     { 
      columns += String.Format(" {0},", val.Key.ToString()); 
      values += String.Format(" '{0}',", val.Value); 
     } 
     columns = columns.Substring(0, columns.Length - 1); 
     values = values.Substring(0, values.Length - 1); 
     try 
     { 
      this.ExecuteNonQuery(String.Format("insert into {0}({1}) values({2});", tableName, columns, values)); 
     } 
     catch (Exception fail) 
     { 
      MessageBox.Show(fail.Message); 
      returnCode = false; 
     } 
     return returnCode; 
    } 

    /// <summary> 
    ///  Allows the programmer to easily delete all data from the DB. 
    /// </summary> 
    /// <returns>A boolean true or false to signify success or failure.</returns> 
    public bool ClearDB() 
    { 
     DataTable tables; 
     try 
     { 
      tables = this.GetDataTable("select NAME from SQLITE_MASTER where type='table' order by NAME;"); 
      foreach (DataRow table in tables.Rows) 
      { 
       this.ClearTable(table["NAME"].ToString()); 
      } 
      return true; 
     } 
     catch 
     { 
      return false; 
     } 
    } 

    /// <summary> 
    ///  Allows the user to easily clear all data from a specific table. 
    /// </summary> 
    /// <param name="table">The name of the table to clear.</param> 
    /// <returns>A boolean true or false to signify success or failure.</returns> 
    public bool ClearTable(String table) 
    { 
     try 
     { 

      this.ExecuteNonQuery(String.Format("delete from {0};", table)); 
      return true; 
     } 
     catch 
     { 
      return false; 
     } 
    } 

} 
}