/// <summary> /// Creates a new connection to the icontent.cache file. /// </summary> /// <param name="filename">The file to connect to.</param> public IGADatabaseConnector(String filename) { try { sqlite = new SqliteConnection("URI=file:" + filename + ",version=3"); sqlite.Open(); SqliteCommand query = new SqliteCommand("SELECT [appId] FROM [contentlist] LIMIT 1", sqlite); Object result = query.ExecuteScalar(); sqlite.Close(); if (result == null) { this._appID = 0; } else { this._appID = (int)result; } if (this._appID > 0) { this._appSupported = Common.AppInfos.ContainsKey(this._appID); } else { this._appSupported = false; } if (this._appSupported) { _appInfo = Common.AppInfos[this._appID]; } } catch (Exception) { throw new DatabaseConnectionFailureException(); } }
protected IDataReader ExecuteReader(SqliteCommand cmd) { SqliteConnection newConnection = (SqliteConnection)((ICloneable)m_Connection).Clone(); newConnection.Open(); cmd.Connection = newConnection; return cmd.ExecuteReader(); }
////////////////////////////////////////////////////////////// // // All non queries are funneled through one connection // to increase performance a little // protected int ExecuteNonQuery(SqliteCommand cmd) { lock (m_Connection) { cmd.Connection = m_Connection; return cmd.ExecuteNonQuery(); } }
// Create SQL Command With Param public SqliteCommand CreateCommand(string sql, Hashtable sqlParams) { SqliteCommand sqlCmd = new SqliteCommand(sql, this); if (sqlParams != null) { foreach (string key in sqlParams.Keys) sqlCmd.Parameters.Add(key, sqlParams[key]); } return(sqlCmd); }
public void WrongSyntax() { SqliteCommand insertCmd = new SqliteCommand("INSERT INTO t1 VALUES (,')",_conn); using(_conn) { _conn.Open(); int res = insertCmd.ExecuteNonQuery(); Assert.AreEqual(res,1); } }
public void InsertRandomValuesWithParameter() { SqliteParameter textP = new SqliteParameter(); textP.ParameterName = "textP"; textP.SourceColumn = "t"; SqliteParameter floatP = new SqliteParameter(); floatP.ParameterName = "floatP"; floatP.SourceColumn = "nu"; SqliteParameter integerP = new SqliteParameter(); integerP.ParameterName ="integerP"; integerP.SourceColumn = "i"; SqliteParameter blobP = new SqliteParameter(); blobP.ParameterName = "blobP"; blobP.SourceColumn = "b"; Random random = new Random(); StringBuilder builder = new StringBuilder(); for (int k=0; k < random.Next(0,100); k++) { builder.Append((char)random.Next(65536)); } SqliteCommand insertCmd = new SqliteCommand("DELETE FROM t1; INSERT INTO t1 (t, f, i, b ) VALUES(:textP,:floatP,:integerP,:blobP)",_conn); insertCmd.Parameters.Add(textP); insertCmd.Parameters.Add(floatP); insertCmd.Parameters.Add(blobP); insertCmd.Parameters.Add(integerP); textP.Value=builder.ToString(); floatP.Value=Convert.ToInt64(random.Next(999)); integerP.Value=random.Next(999); blobP.Value=System.Text.Encoding.UTF8.GetBytes("\u05D0\u05D1\u05D2" + builder.ToString()); SqliteCommand selectCmd = new SqliteCommand("SELECT * from t1", _conn); using(_conn) { _conn.Open(); int res = insertCmd.ExecuteNonQuery(); Assert.AreEqual(res,1); using (IDataReader reader = selectCmd.ExecuteReader()) { Assert.AreEqual(reader.Read(), true); Assert.AreEqual(reader["t"], textP.Value); Assert.AreEqual(reader["f"], floatP.Value); Assert.AreEqual(reader["i"], integerP.Value); Assert.AreEqual(reader["b"], blobP.Value); Assert.AreEqual(reader.Read(), false); } } }
public new void ExecuteNonQuery(string sql, string connectionString) { using (SqliteConnection conn = new SqliteConnection(connectionString)) { SqliteCommand cmd = new SqliteCommand(sql, conn); cmd.CommandTimeout = 1200; conn.Open(); cmd.ExecuteNonQuery(); conn.Close(); } }
public new object ExecuteScalar(string sql, string connectionString) { using (SqliteConnection conn = new SqliteConnection(connectionString)) { SqliteCommand cmd = new SqliteCommand(sql, conn); cmd.CommandTimeout = 1200; conn.Open(); object retVal = cmd.ExecuteScalar(); conn.Close(); return retVal; } }
internal SqliteDataReader (SqliteCommand cmd, IntPtr pVm, int version) { command = cmd; rows = new ArrayList (); columns = new ArrayList (); column_names = new Hashtable (); closed = false; current_row = -1; reading = true; ReadpVm (pVm, version); ReadingDone (); }
public bool Convert() { try { SqliteConnection conn = new SqliteConnection(m_connectionString); conn.Open(); Assembly assem = GetType().Assembly; Migration m = new Migration(conn, assem, "RegionStore"); int version = m.Version; if (version <= 14) { if (version == 0) { //read rex tables and add to rex database m_log.Info("[regionstore] converting rex tables to rexobjectproperties"); if (!ConvertLegacyRexDataToModreX()) { conn.Close(); return false; } m_log.Info("[RegionStore] Update region migrations"); //Add new field to Land table SqliteCommand addAuthbyerIDCmd = new SqliteCommand(addAuthbyerID, conn); addAuthbyerIDCmd.ExecuteNonQuery(); //Change migration to version 1 m.Version = 1; } //Run migrations up to 9 //Note: this run migrations only to point nine since only those files exist in application resources. m.Update(); //Skip over 10. Change version to 10 //This skips adding of the ClickAction since that already exists in 0.4 database //m.Version = 10; } conn.Close(); return true; } catch (Exception e) { m_log.ErrorFormat("[RegionStore] Migration failed. Reason: {0}", e); return false; } }
public AuthenticationData Get(UUID principalID) { AuthenticationData ret = new AuthenticationData(); ret.Data = new Dictionary<string, object>(); SqliteCommand cmd = new SqliteCommand("select * from `" + m_Realm + "` where UUID = :PrincipalID"); cmd.Parameters.Add(new SqliteParameter(":PrincipalID", principalID.ToString())); IDataReader result = ExecuteReader(cmd, m_Connection); try { if (result.Read()) { ret.PrincipalID = principalID; if (m_ColumnNames == null) { m_ColumnNames = new List<string>(); DataTable schemaTable = result.GetSchemaTable(); foreach (DataRow row in schemaTable.Rows) m_ColumnNames.Add(row["ColumnName"].ToString()); } foreach (string s in m_ColumnNames) { if (s == "UUID") continue; ret.Data[s] = result[s].ToString(); } return ret; } else { return null; } } catch { } finally { CloseCommand(cmd); } return null; }
protected IDataReader ExecuteReader(SqliteCommand cmd, SqliteConnection connection) { lock (connection) { SqliteConnection newConnection = (SqliteConnection)((ICloneable)connection).Clone(); newConnection.Open(); cmd.Connection = newConnection; //Console.WriteLine("XXX " + cmd.CommandText); return cmd.ExecuteReader(); } }
public Database(string file) { bool create = false; if (!File.Exists (file)) { create = true; } try { StreamReader srVersion = new StreamReader (file+".version"); dbVersion = srVersion.ReadToEnd (); if (dbVersion != null) { dbVersion = dbVersion.Trim(); } srVersion.Close(); } catch { dbVersion = null; } string connectionString = "URI=file:"+file; connection = new SqliteConnection(connectionString); connection.Open(); command = connection.CreateCommand(); if (create) { Conf.EmptyCache(); Assembly thisAssembly = Assembly.GetEntryAssembly (); Stream stream = thisAssembly.GetManifestResourceStream("Database.sql"); if (stream != null) { StreamReader sr = new StreamReader (stream); string sql = sr.ReadToEnd(); command.CommandText = sql; command.ExecuteNonQuery(); StreamWriter swVersion = new StreamWriter (file+".version", false); swVersion.Write (Defines.VERSION); swVersion.Close(); dbVersion = Defines.VERSION; } else { System.Console.WriteLine("Error creating the database"); } } if (dbVersion == null || !dbVersion.Equals (Defines.VERSION)) { UpdateDatabase(file, dbVersion); } }
internal SqliteDataReader (SqliteCommand cmd, IntPtr pVm, int version) { command = cmd; rows = new ArrayList (); column_names_sens = new Hashtable (); #if NET_2_0 column_names_insens = new Hashtable (StringComparer.InvariantCultureIgnoreCase); #else column_names_insens = new Hashtable (CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant); #endif closed = false; current_row = -1; reading = true; ReadpVm (pVm, version, cmd); ReadingDone (); }
static SqliteDataAdapter PrepareDataAdapter() { SqliteCommand select = new SqliteCommand("SELECT t, f, i, b FROM t1",_conn); SqliteCommand update = new SqliteCommand("UPDATE t1 SET t = :textP, f = :floatP, i = :integerP, n=:blobP WHERE t = :textP "); update.Connection=_conn; SqliteCommand delete = new SqliteCommand("DELETE FROM t1 WHERE t = :textP"); delete.Connection=_conn; SqliteCommand insert = new SqliteCommand("INSERT INTO t1 (t, f, i, b ) VALUES(:textP,:floatP,:integerP,:blobP)"); insert.Connection=_conn; SqliteDataAdapter custDA = new SqliteDataAdapter(select); SqliteParameter textP = new SqliteParameter(); textP.ParameterName = "textP"; textP.SourceColumn = "t"; SqliteParameter floatP = new SqliteParameter(); floatP.ParameterName = "floatP"; floatP.SourceColumn = "f"; SqliteParameter integerP = new SqliteParameter(); integerP.ParameterName ="integerP"; integerP.SourceColumn = "i"; SqliteParameter blobP = new SqliteParameter(); blobP.ParameterName = "blobP"; blobP.SourceColumn = "b"; update.Parameters.Add(textP); update.Parameters.Add(floatP); update.Parameters.Add(integerP); update.Parameters.Add(blobP); delete.Parameters.Add(textP); insert.Parameters.Add(textP); insert.Parameters.Add(floatP); insert.Parameters.Add(integerP); insert.Parameters.Add(blobP); custDA.UpdateCommand = update; custDA.DeleteCommand = delete; custDA.InsertCommand = insert; return custDA; }
public void Select() { SqliteCommand simpleSelect = new SqliteCommand("SELECT * FROM t1; ", _conn); // check trailing spaces using(_conn) { _conn.Open(); SqliteDataReader dr = simpleSelect.ExecuteReader(); while(dr.Read()) { string test = dr[0].ToString(); Assert.AreEqual(dr["T"], stringvalue); // also checks case-insensitive column Assert.AreEqual(dr["F"], 123); Assert.AreEqual(dr["I"], 123); Assert.AreEqual(dr["B"], "123"); } Assert.IsTrue(dr.FieldCount>0); } }
public bool Convert() { try { SqliteConnection conn = new SqliteConnection(m_connectionString); conn.Open(); Assembly assem = GetType().Assembly; Migration m = new Migration(conn, assem, "InventoryStore"); if (m.Version == 0) { //Apply all changes to db SqliteCommand addSalePriceCmd = new SqliteCommand(addSalePrice, conn); addSalePriceCmd.ExecuteNonQuery(); SqliteCommand addSaleTypeCmd = new SqliteCommand(addSaleType, conn); addSaleTypeCmd.ExecuteNonQuery(); SqliteCommand addCreationDateCmd = new SqliteCommand(addCreationDate, conn); addCreationDateCmd.ExecuteNonQuery(); SqliteCommand addGroupIDCmd = new SqliteCommand(addGroupID, conn); addGroupIDCmd.ExecuteNonQuery(); SqliteCommand addGroupOwnedCmd = new SqliteCommand(addGroupOwned, conn); addGroupOwnedCmd.ExecuteNonQuery(); SqliteCommand addFlagsCmd = new SqliteCommand(addFlags, conn); addFlagsCmd.ExecuteNonQuery(); //then change version number m.Version = 1; } return true; } catch (Exception e) { m_log.ErrorFormat("[InventoryStore] Migration failed. Reason: {0}", e); return false; } }
public string Get(string scope, string key) { string command = "SELECT `value` FROM `generic` WHERE `key` = @key"; if (!String.IsNullOrEmpty(scope)) command += " AND `scope` = @scope"; lock (this) { using (SqliteCommand cmd = new SqliteCommand(command, m_Connection)) { cmd.Parameters.Add("@key", key); if (!String.IsNullOrEmpty(scope)) cmd.Parameters.Add("@scope", scope); using (IDataReader result = cmd.ExecuteReader()) { if (result.Read()) return result.GetString(0); else return null; } } } }
public void Create() { try { if(File.Exists(_uri)) { _conn.Dispose(); // We want to start with a fresh db for each full run // The database is created on the first open() File.Delete(_uri); _conn = new SqliteConnection (_connectionString); } } catch(Exception e) { throw e; } SqliteCommand createCommand = new SqliteCommand("CREATE TABLE t1(t TEXT, f FLOAT, i INTEGER, b TEXT);",_conn); SqliteCommand insertCommand = new SqliteCommand("INSERT INTO t1 (t, f, i, b ) VALUES('" + stringvalue + "',123,123,'123')",_conn); try { _conn.Open(); createCommand.ExecuteNonQuery(); insertCommand.ExecuteNonQuery(); } catch(Exception e) { throw new AssertionException("Create table failed",e); } finally { _conn.Close(); } }
/// <summary> /// <list type="bullet"> /// <item>Initialises Inventory interface</item> /// <item>Loads and initialises a new SQLite connection and maintains it.</item> /// <item>use default URI if connect string string is empty.</item> /// </list> /// </summary> /// <param name="dbconnect">connect string</param> public void Initialise(string dbconnect) { if (dbconnect == string.Empty) { dbconnect = "URI=file:inventoryStore.db,version=3"; } m_log.Info("[INVENTORY DB]: Sqlite - connecting: " + dbconnect); conn = new SqliteConnection(dbconnect); conn.Open(); Assembly assem = GetType().Assembly; Migration m = new Migration(conn, assem, "InventoryStore"); m.Update(); SqliteCommand itemsSelectCmd = new SqliteCommand(invItemsSelect, conn); invItemsDa = new SqliteDataAdapter(itemsSelectCmd); // SqliteCommandBuilder primCb = new SqliteCommandBuilder(primDa); SqliteCommand foldersSelectCmd = new SqliteCommand(invFoldersSelect, conn); invFoldersDa = new SqliteDataAdapter(foldersSelectCmd); ds = new DataSet(); ds.Tables.Add(createInventoryFoldersTable()); invFoldersDa.Fill(ds.Tables["inventoryfolders"]); setupFoldersCommands(invFoldersDa, conn); m_log.Info("[INVENTORY DB]: Populated Inventory Folders Definitions"); ds.Tables.Add(createInventoryItemsTable()); invItemsDa.Fill(ds.Tables["inventoryitems"]); setupItemsCommands(invItemsDa, conn); m_log.Info("[INVENTORY DB]: Populated Inventory Items Definitions"); ds.AcceptChanges(); }
public stats_default_page_values rep_DefaultReport_data(SqliteConnection db, List<Scene> m_scene) { stats_default_page_values returnstruct = new stats_default_page_values(); returnstruct.all_scenes = m_scene.ToArray(); lock (db) { string SQL = @"SELECT COUNT(DISTINCT agent_id) as agents, COUNT(*) as sessions, AVG(avg_fps) as client_fps, AVG(avg_sim_fps) as savg_sim_fps, AVG(avg_ping) as sav_ping, SUM(n_out_kb) as num_in_kb, SUM(n_out_pk) as num_in_packets, SUM(n_in_kb) as num_out_kb, SUM(n_in_pk) as num_out_packets, AVG(mem_use) as sav_mem_use FROM stats_session_data;"; SqliteCommand cmd = new SqliteCommand(SQL, db); SqliteDataReader sdr = cmd.ExecuteReader(); if (sdr.HasRows) { sdr.Read(); returnstruct.total_num_users = Convert.ToInt32(sdr["agents"]); returnstruct.total_num_sessions = Convert.ToInt32(sdr["sessions"]); returnstruct.avg_client_fps = Convert.ToSingle(sdr["client_fps"]); returnstruct.avg_sim_fps = Convert.ToSingle(sdr["savg_sim_fps"]); returnstruct.avg_ping = Convert.ToSingle(sdr["sav_ping"]); returnstruct.total_kb_out = Convert.ToSingle(sdr["num_out_kb"]); returnstruct.total_kb_in = Convert.ToSingle(sdr["num_in_kb"]); returnstruct.avg_client_mem_use = Convert.ToSingle(sdr["sav_mem_use"]); } } return returnstruct; }
private bool ExistsFirstLastName(String fname, String lname) { string FindUser = "******"; using (SqliteCommand cmd = new SqliteCommand(FindUser, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":username", fname)); cmd.Parameters.Add(new SqliteParameter(":surname", lname)); try { using (IDataReader reader = cmd.ExecuteReader()) { if (reader.Read()) { reader.Close(); return true; } else { reader.Close(); return false; } } } catch (Exception ex) { m_log.Error("[USER DB]: Exception searching for user's first and last name: " + ex.ToString()); return false; } } }
/// <summary> /// /// </summary> /// <param name="queryID"></param> /// <param name="query"></param> /// <returns></returns> override public List<AvatarPickerAvatar> GeneratePickerResults(UUID queryID, string query) { List<AvatarPickerAvatar> returnlist = new List<AvatarPickerAvatar>(); string[] querysplit; querysplit = query.Split(' '); if (querysplit.Length == 2) { using (SqliteCommand cmd = new SqliteCommand(AvatarPickerAndSQL, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":username", querysplit[0] + "%")); cmd.Parameters.Add(new SqliteParameter(":surname", querysplit[1] + "%")); using (IDataReader reader = cmd.ExecuteReader()) { while (reader.Read()) { AvatarPickerAvatar user = new AvatarPickerAvatar(); user.AvatarID = new UUID((string) reader["UUID"]); user.firstName = (string) reader["username"]; user.lastName = (string) reader["surname"]; returnlist.Add(user); } reader.Close(); } } } else if (querysplit.Length == 1) { using (SqliteCommand cmd = new SqliteCommand(AvatarPickerOrSQL, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":username", querysplit[0] + "%")); cmd.Parameters.Add(new SqliteParameter(":surname", querysplit[0] + "%")); using (IDataReader reader = cmd.ExecuteReader()) { while (reader.Read()) { AvatarPickerAvatar user = new AvatarPickerAvatar(); user.AvatarID = new UUID((string) reader["UUID"]); user.firstName = (string) reader["username"]; user.lastName = (string) reader["surname"]; returnlist.Add(user); } reader.Close(); } } } return returnlist; }
/// <summary> /// Get (fetch?) the friendlist for a user /// </summary> /// <param name="friendlistowner">UUID of the friendlist owner</param> /// <returns>The friendlist list</returns> override public List<FriendListItem> GetUserFriendList(UUID friendlistowner) { List<FriendListItem> returnlist = new List<FriendListItem>(); using (SqliteCommand cmd = new SqliteCommand(SelectFriendsByUUID, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.ToString())); try { using (IDataReader reader = cmd.ExecuteReader()) { while (reader.Read()) { FriendListItem user = new FriendListItem(); user.FriendListOwner = friendlistowner; user.Friend = new UUID((string)reader[0]); user.FriendPerms = Convert.ToUInt32(reader[1]); user.FriendListOwnerPerms = Convert.ToUInt32(reader[2]); returnlist.Add(user); } reader.Close(); } } catch (Exception ex) { m_log.Error("[USER DB]: Exception getting friends list for user: " + ex.ToString()); } } return returnlist; }
/// <summary> /// Update the friendlist permission /// </summary> /// <param name="friendlistowner">UUID of the friendlist owner</param> /// <param name="friend">UUID of the friend to modify</param> /// <param name="perms">updated permission flag</param> override public void UpdateUserFriendPerms(UUID friendlistowner, UUID friend, uint perms) { string UpdatePerms = "update userfriends set friendPerms=:perms where ownerID=:ownerID and friendID=:friendID"; using (SqliteCommand cmd = new SqliteCommand(UpdatePerms, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":perms", perms)); cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.ToString())); cmd.Parameters.Add(new SqliteParameter(":friendID", friend.ToString())); cmd.ExecuteNonQuery(); } }
/// <summary> /// Remove a user from the friendlist /// </summary> /// <param name="friendlistowner">UUID of the friendlist owner</param> /// <param name="friend">UUID of the friend to remove</param> override public void RemoveUserFriend(UUID friendlistowner, UUID friend) { string DeletePerms = "delete from userfriends where (ownerID=:ownerID and friendID=:friendID) or (ownerID=:friendID and friendID=:ownerID)"; using (SqliteCommand cmd = new SqliteCommand(DeletePerms, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.ToString())); cmd.Parameters.Add(new SqliteParameter(":friendID", friend.ToString())); cmd.ExecuteNonQuery(); } }
/// <summary> /// Add a new friend in the friendlist /// </summary> /// <param name="friendlistowner">UUID of the friendlist owner</param> /// <param name="friend">UUID of the friend to add</param> /// <param name="perms">permission flag</param> override public void AddNewUserFriend(UUID friendlistowner, UUID friend, uint perms) { if (ExistsFriend(friendlistowner, friend)) return; string InsertFriends = "insert into userfriends(ownerID, friendID, friendPerms) values(:ownerID, :friendID, :perms)"; using (SqliteCommand cmd = new SqliteCommand(InsertFriends, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.ToString())); cmd.Parameters.Add(new SqliteParameter(":friendID", friend.ToString())); cmd.Parameters.Add(new SqliteParameter(":perms", perms)); cmd.ExecuteNonQuery(); } using (SqliteCommand cmd = new SqliteCommand(InsertFriends, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":ownerID", friend.ToString())); cmd.Parameters.Add(new SqliteParameter(":friendID", friendlistowner.ToString())); cmd.Parameters.Add(new SqliteParameter(":perms", perms)); cmd.ExecuteNonQuery(); } }
private bool ExistsFriend(UUID owner, UUID friend) { string FindFriends = "select * from userfriends where (ownerID=:ownerID and friendID=:friendID) or (ownerID=:friendID and friendID=:ownerID)"; using (SqliteCommand cmd = new SqliteCommand(FindFriends, g_conn)) { cmd.Parameters.Add(new SqliteParameter(":ownerID", owner.ToString())); cmd.Parameters.Add(new SqliteParameter(":friendID", friend.ToString())); try { using (IDataReader reader = cmd.ExecuteReader()) { if (reader.Read()) { reader.Close(); return true; } else { reader.Close(); return false; } } } catch (Exception ex) { m_log.Error("[USER DB]: Exception getting friends list for user: " + ex.ToString()); return false; } } }
/// <summary> /// /// </summary> /// <param name="daf"></param> /// <param name="conn"></param> private void setupAvatarAppearanceCommands(SqliteDataAdapter daa, SqliteConnection conn) { daa.InsertCommand = SQLiteUtil.createInsertCommand("avatarappearance", ds.Tables["avatarappearance"]); daa.InsertCommand.Connection = conn; daa.UpdateCommand = SQLiteUtil.createUpdateCommand("avatarappearance", "Owner=:Owner", ds.Tables["avatarappearance"]); daa.UpdateCommand.Connection = conn; SqliteCommand delete = new SqliteCommand("delete from avatarappearance where Owner=:Owner"); delete.Parameters.Add(SQLiteUtil.createSqliteParameter("Owner", typeof(String))); delete.Connection = conn; daa.DeleteCommand = delete; }
/// <summary> /// /// </summary> /// <param name="daf"></param> /// <param name="conn"></param> private void setupUserFriendsCommands(SqliteDataAdapter daf, SqliteConnection conn) { daf.InsertCommand = SQLiteUtil.createInsertCommand("userfriends", ds.Tables["userfriends"]); daf.InsertCommand.Connection = conn; daf.UpdateCommand = SQLiteUtil.createUpdateCommand("userfriends", "ownerID=:ownerID and friendID=:friendID", ds.Tables["userfriends"]); daf.UpdateCommand.Connection = conn; SqliteCommand delete = new SqliteCommand("delete from userfriends where ownerID=:ownerID and friendID=:friendID"); delete.Parameters.Add(SQLiteUtil.createSqliteParameter("ownerID", typeof(String))); delete.Parameters.Add(SQLiteUtil.createSqliteParameter("friendID", typeof(String))); delete.Connection = conn; daf.DeleteCommand = delete; }