public LibraryDatabaseManager(String dbFolderPath) { DatabaseFile = String.Format(dbFolderPath + "{0}Library.db", Path.DirectorySeparatorChar); Connection = new SqliteConnection ( "Data Source = " + LibraryDatabaseManager.DatabaseFile + "; Version = 3;"); bool exists = File.Exists (LibraryDatabaseManager.DatabaseFile); if (!exists) { SqliteConnection.CreateFile (LibraryDatabaseManager.DatabaseFile); } Connection.Open (); if (!exists) { using (SqliteCommand command = new SqliteCommand (Connection)) { command.CommandText = "CREATE TABLE Books (" + "BookID INTEGER PRIMARY KEY NOT NULL, " + "BookTitle TEXT, " + "BookAuthor TEXT, " + "BookGenre TEXT, " + "BookPublishedYear INTEGER, " + "BookPath TEXT);"; command.ExecuteNonQuery(); } } }
/** * Constructor will try and open the database if none exsists it will create one * In addition it will create new tables if non exsist. */ public SqlWrapper(GameObjectList objectList) { gameObjectList = objectList; //try and open database, if failed make one! Database = new sqliteConnection("Data Source=Dungeon" + ";Version=3;FailIfMissing=True"); try { Database.Open(); } catch { Console.WriteLine("Open existing DB failed: So creating one"); sqliteConnection.CreateFile("Dungeon"); Database = new sqliteConnection("Data Source=Dungeon" + ";Version=3;FailIfMissing=True"); Database.Open(); } //do the disable roll back thingy //Not sure what this does, fixed a problem, found it on stack overflow String disableRollback = "PRAGMA journal_mode = OFF"; sqliteCommand cmd = new sqliteCommand(); cmd.Connection = Database; cmd.CommandText = disableRollback; cmd.ExecuteNonQuery(); //create tables new sqliteCommand(createTable + itemTableName + itemColumns, Database).ExecuteNonQuery(); new sqliteCommand(createTable + playerTableName + playerColumns, Database).ExecuteNonQuery(); }
/** * Used if loading from an exsisitng dungeon. It will cycle through the dungeon table * getting all the rooms and adding them to the new dungeons room list * Having the dungeon as dynamic memory, allows for quicker sanity checks incase * players try and break things. The databse is always written to if the player * actuallty does anything. */ public Dungeon GetDungeon() { Dungeon d = new Dungeon(); try { var command = new sqliteCommand("select * from " + dungeonTableName, Database); var reader = command.ExecuteReader(); while (reader.Read()) { Room r = new Room(); r.name = reader["name"].ToString(); r.desc = reader["description"].ToString(); r.RoomIndex = Int32.Parse(reader["rIndex"].ToString()); r.north = Int32.Parse(reader["north"].ToString()); r.east = Int32.Parse(reader["east"].ToString()); r.south = Int32.Parse(reader["south"].ToString()); r.west = Int32.Parse(reader["west"].ToString()); d.GetRoomList().Add(r); } reader.Close(); Console.WriteLine(""); } catch (Exception ex) { Console.WriteLine("Failed to display DB" + ex); } return(d); }
/** * Adds a new player to the player table * @param tempPlayer the player so far that we will add. * @param password the salted-hashes password the player used to login * @param salt the salt used to hash the password and used for encryption */ public bool AddPlayer(Player tempPlayer, String password, String salt) { var command = new sqliteCommand("select * from " + playerTableName + " where name =:id", Database); command.Parameters.Add("id", DbType.String).Value = tempPlayer.PlayerName; var reader = command.ExecuteReader(); if (reader.HasRows == false && !U.HasBadChars(tempPlayer.PlayerName) && !U.HasBadChars(password)) { try { command = new sqliteCommand("INSERT INTO " + playerTableName + " (name, password, salt, rIndex) " + "VALUES ($n, $p, $s, $i) ", Database); command.Parameters.Add("$n", DbType.String).Value = tempPlayer.PlayerName; command.Parameters.Add("$p", DbType.String).Value = password; command.Parameters.Add("$s", DbType.String).Value = salt; command.Parameters.Add("$i", DbType.Int32).Value = tempPlayer.RoomIndex; command.ExecuteNonQuery(); ActivePlayers.Add(tempPlayer.PlayerName); return(true); } catch (Exception ex) { Console.WriteLine("Failed Adding to DB: " + ex); return(false); } } else { return(false); } }
/** * Get all items with where the owner field is equal to that of the players name * @param owner the entity to whom the items belong. */ public String GetOwnedItems(String owner) { String rString = U.NL(""); var command = new sqliteCommand("select * from " + itemTableName + " where owner =:name ", Database); command.Parameters.Add("name", DbType.String).Value = owner; try { var reader = command.ExecuteReader(); while (reader.Read()) { //make the description String id = reader["itemID"].ToString(); rString += U.NL("Name: " + gameObjectList.GetItem(id).itemName); rString += U.NL("Description: " + gameObjectList.GetItem(id).description); U.NL(""); } } catch (Exception ex) { Console.Write("Failed to get inventory" + ex); rString += "Could not find items"; } return(rString); }
/** * Try and move an item from an oldowner to a new owner * @param oldOwner the owner trying to move the item from * @param newOwner the owner tyring to move the item too. * @param item the name of the item to be moved. */ public String MoveItem(String oldOwner, String newOwner, String item) { var command = new sqliteCommand("select * from " + itemTableName + " where owner =:owner AND name =:item ", Database); command.Parameters.Add("owner", DbType.String).Value = oldOwner; command.Parameters.Add("item", DbType.String).Value = item; try { var reader = command.ExecuteReader(); if (reader.HasRows) { reader.Read(); if (ChangeItemOwner(reader["uniqueID"].ToString(), newOwner)) { return("You "); } } } catch (Exception ex) { Console.Write("Item Not recognised: " + ex); } return("Failed To "); }
private void apply_Click(object sender, EventArgs e) { SqliteCommand command = new SqliteCommand(connection); String date = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); command.CommandText = "INSERT OR REPLACE INTO comments (guid, comment, date) VALUES (@guid, @comment, @date)"; command.Parameters.Add(new SqliteParameter("@guid", guid)); command.Parameters.Add(new SqliteParameter("@comment", input.Text)); command.Parameters.Add(new SqliteParameter("@date", date)); command.ExecuteNonQuery(); command.Dispose(); if (mode == "players") { Thread thread = new Thread(new ThreadStart(gui.thread_Player)); thread.IsBackground = true; thread.Start(); } else if (mode == "bans") { Thread thread = new Thread(new ThreadStart(gui.thread_Bans)); thread.IsBackground = true; thread.Start(); } else if (mode == "player database") { Thread thread = new Thread(new ThreadStart(gui.thread_Database)); thread.IsBackground = true; thread.Start(); } this.Close(); }
public override void update(ActionTimer timer) { List <Account> _list = new List <Account>(); using (SQLiteCommand command = new SQLiteCommand(Sqlite.getSqlite().connection)) { command.CommandText = "SELECT id, name FROM `account`"; using (SQLiteDataReader sdrITM = command.ExecuteReader()) { if (sdrITM.HasRows) { while (sdrITM.Read()) { int accID = Convert.ToInt32(sdrITM["id"]); string name = Convert.ToString(sdrITM["name"]); _list.Add(new Account() { accountID = accID, name = name }); } } } } list = _list.ToArray(); isFinished = true; timer.removeAction(this); }
public bool register(String name, String password) { if (existsName(name)) { return(false); } //Setting default parameter! Can be overwritten by other modules, after registration! player.setSpawnInfos(@"NEWWORLD\NEWWORLD.ZEN", null, null); player.HPMax = 10; player.HP = 10; using (SQLiteCommand command = new SQLiteCommand(Sqlite.getSqlite().connection)) { command.CommandText = "INSERT INTO `account` ("; command.CommandText += " `id`, `name`, `password`, `posx`, `posy`, `posz`, `world`)"; command.CommandText += "VALUES( NULL, @name, @password, @posx, @posy, @posz, @world)"; command.Parameters.AddWithValue("@name", name); command.Parameters.AddWithValue("@password", password); command.Parameters.AddWithValue("@posx", 0); command.Parameters.AddWithValue("@posy", 0); command.Parameters.AddWithValue("@posz", 0); command.Parameters.AddWithValue("@world", player.Map); command.ExecuteNonQuery(); command.CommandText = @"select last_insert_rowid()"; accountID = (long)command.ExecuteScalar(); } state = State.LoggedIn; return(true); }
public static void log_CharacterStat(NPCProto proto, CharStat stat, int value) { if (proto is NPC) { return; } Player player = (Player)proto; if (player.getAccount() == null || !player.IsSpawned()) { return; } lock (connection) { using (SQLiteCommand command = new SQLiteCommand(connection)) { command.CommandText = "INSERT INTO `logStats` ("; command.CommandText += " `id`, `accountID`, `type`, `value`, `time`)"; command.CommandText += "VALUES( NULL, @accID, @type, @value, @time)"; command.Parameters.AddWithValue("@accID", player.getAccount().accountID); command.Parameters.AddWithValue("@type", (int)stat); command.Parameters.AddWithValue("@value", value); command.Parameters.AddWithValue("@time", DateTime.Now.Ticks); command.ExecuteNonQuery(); } } }
/// <summary> /// Clears all items from the database where their PublishDate is before the date provided. /// </summary> /// <param name="date"></param> public void ClearItemsBeforeDate(DateTime date) { try { using (SqliteConnection connection = new SqliteConnection(ItemsConnectionString)) { connection.Open(); using (SqliteCommand command = new SqliteCommand(connection)) { string sql = @"DELETE FROM items WHERE DATETIME(publishdate) <= DATETIME(@date)"; command.CommandText = sql; SqliteParameter parameter = new SqliteParameter("@date", DbType.String); parameter.Value = date.ToString("yyyy-MM-dd HH:mm:ss"); command.Parameters.Add(parameter); int rows = command.ExecuteNonQuery(); Logger.Info("ClearItemsBeforeDate before {0} cleared {1} rows.", date.ToString("yyyy-MM-dd HH:mm:ss"), rows); } } } catch (SqliteException e) { Logger.Warn("SqliteException occured while clearing items before {0}: \n{1}", date, e); } }
private static void InitDefaultTables() { using (SQLiteCommand command = new SQLiteCommand(connection)) { command.CommandText = "CREATE TABLE IF NOT EXISTS `logStats` ("; command.CommandText += " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"; command.CommandText += " `accountID` INTEGER NOT NULL,"; command.CommandText += " `type` INTEGER NOT NULL,"; command.CommandText += " `value` INTEGER NOT NULL,"; command.CommandText += " `time` INTEGER NOT NULL"; command.CommandText += ")"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS `logEvents` ("; command.CommandText += " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"; command.CommandText += " `accountID` INTEGER NOT NULL,"; command.CommandText += " `InteractAccountID` INTEGER NOT NULL,"; command.CommandText += " `type` INTEGER NOT NULL,"; command.CommandText += " `lastPing` INTEGER NOT NULL,"; command.CommandText += " `averagePing` INTEGER NOT NULL,"; command.CommandText += " `time` INTEGER NOT NULL,"; command.CommandText += " `message` TEXT NOT NULL"; command.CommandText += ")"; command.ExecuteNonQuery(); } }
public bool ExcuteTransaction(string sql) { var cmds = sql.Split(';'); using (SqliteConnection conn = new SqliteConnection(this.SqlConfig.ConnectionString)) { conn.Open(); SqliteCommand cmd = new SqliteCommand(conn); SqliteTransaction tran = conn.BeginTransaction(); try { foreach (var cmdSql in cmds) { cmd.CommandText = cmdSql; cmd.ExecuteNonQuery(); } tran.Commit(); conn.Close(); return true; } catch (Exception e) { tran.Rollback(); conn.Close(); throw new Exception(e.Message + " sql:" + sql); } finally { conn.Close(); } } }
public static void Init() { try { _cards = new Dictionary<int, CardData>(); string currentPath = Assembly.GetExecutingAssembly().Location; currentPath = Path.GetDirectoryName(currentPath) ?? ""; string absolutePath = Path.Combine(currentPath, "cards.cdb"); if (!File.Exists(absolutePath)) { throw new Exception("Could not find the cards database."); } using (SqliteConnection connection = new SqliteConnection("Data Source=" + absolutePath)) { connection.Open(); const string select = "SELECT datas.id, alias, type, level, race, attribute, atk, def, name, desc " + "FROM datas INNER JOIN texts ON datas.id = texts.id"; using (SqliteCommand command = new SqliteCommand(select, connection)) using (SqliteDataReader reader = command.ExecuteReader()) InitCards(reader); } } catch (Exception ex) { throw new Exception("Could not initialize the cards database. Check the inner exception for more details.", ex); } }
protected int ExecuteNonQuery(SqliteCommand cmd) { try { lock (m_Connection) { var newConnection = (SqliteConnection)((ICloneable)m_Connection).Clone(); if (newConnection.State != ConnectionState.Open) newConnection.Open(); cmd.Connection = newConnection; return cmd.ExecuteNonQuery(); } } catch (Mono.Data.Sqlite.SqliteException) { //m_log.Warn("[SQLiteDataManager]: Exception processing command: " + cmd.CommandText + ", Exception: " + ex); //throw ex; } catch (Exception ex) { m_log.Warn("[SQLiteDataManager]: Exception processing command: " + cmd.CommandText + ", Exception: " + ex); throw ex; } return 0; }
public void DateTimeConvert () { var dateTime = new DateTime (2016, 9, 15, 12, 1, 53); var guid = Guid.NewGuid (); using (var connection = new SqliteConnection ("Data Source=" + _databasePath)) { connection.Open (); var sqlCreate = "CREATE TABLE TestTable (ID uniqueidentifier PRIMARY KEY, Modified datetime)"; using (var cmd = new SqliteCommand (sqlCreate, connection)) { cmd.ExecuteNonQuery (); } var sqlInsert = "INSERT INTO TestTable (ID, Modified) VALUES (@id, @mod)"; using (var cmd = new SqliteCommand (sqlInsert, connection)) { cmd.Parameters.Add (new SqliteParameter ("@id", guid)); cmd.Parameters.Add (new SqliteParameter ("@mod", dateTime)); cmd.ExecuteNonQuery (); } } using (var connection = new SqliteConnection ("Data Source=" + _databasePath)) { connection.Open (); var sqlSelect = "SELECT * from TestTable"; using (var cmd = new SqliteCommand (sqlSelect, connection)) using (var reader = cmd.ExecuteReader ()) { while (reader.Read ()) { Assert.AreEqual (guid, reader.GetGuid (0), "#1"); Assert.AreEqual (dateTime, reader.GetDateTime (1), "#2"); } } } }
public void Create() { try { if(File.Exists(dbPath)) { cnn.Dispose(); // We want to start with a fresh db for each full run // The database is created on the first open() File.Delete(dbPath); } } catch(Exception e) { throw e; } try { using (var createCommand = new SqliteCommand ("CREATE TABLE Company (RecordId int, Name text);", cnn)) using (var insertCommand = new SqliteCommand ("INSERT INTO Company VALUES (1, 'Test CO')", cnn)) { cnn.Open(); createCommand.ExecuteNonQuery(); insertCommand.ExecuteNonQuery(); } } catch(Exception e) { Console.WriteLine (e); throw new AssertionException ("Create table failed", e); } finally { cnn.Close(); } }
private bool _CreateDB() { if (_Connection == null) return false; try { using (SQLiteCommand command = new SQLiteCommand(_Connection)) { command.CommandText = "CREATE TABLE IF NOT EXISTS Version (Value INTEGER NOT NULL);"; command.ExecuteNonQuery(); command.CommandText = "INSERT INTO Version (Value) VALUES(0)"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS Images ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + "Path TEXT NOT NULL, width INTEGER NOT NULL, height INTEGER NOT NULL);"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS ImageData ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + "ImageID INTEGER NOT NULL, Data BLOB NOT NULL);"; command.ExecuteNonQuery(); } } catch (Exception e) { CLog.Error("Error creating Ressource DB " + e); return false; } return true; }
public void CloseSqlConnection() { if (dbCommand != null) { dbCommand.Dispose (); } dbCommand = null; if (reader != null) { reader.Dispose (); } reader = null; if (dbConnection != null) { dbConnection.Close (); } dbConnection = null; Debug.Log ("Disconnected from db."); }
public DBManager(string DatabaseName) { if (!File.Exists(DatabaseName)) { SqliteConnection.CreateFile(DatabaseName); } dbConnection = new SqliteConnection("Data Source=" + DatabaseName + ";Version=3;"); dbConnection.Open(); cmd = dbConnection.CreateCommand(); string checkForTable = "SELECT name FROM sqlite_master WHERE type='table' AND name='users';"; cmd.CommandText = checkForTable; if (cmd.ExecuteNonQuery() == 0) { string create = "CREATE TABLE users (id INT PRIMARY KEY, name CHAR(50));"; cmd = dbConnection.CreateCommand(); cmd.CommandText = create; try { cmd.ExecuteNonQuery(); } catch { System.Diagnostics.Debug.WriteLine("Table already exists..."); } } cmd = null; }
public static bool Init() { try { m_cards = new Dictionary <int, CardData>(); string currentPath = System.Reflection.Assembly.GetExecutingAssembly().Location; currentPath = Path.GetDirectoryName(currentPath) ?? ""; string absolutePath = Path.Combine(currentPath, "Content/cards.cdb"); if (!File.Exists(absolutePath)) { return(false); } using (SQLiteConnection connection = new SQLiteConnection("Data Source=" + absolutePath)) { connection.Open(); const string select = "SELECT datas.id, alias, type, level, race, attribute, atk, def, name, desc " + "FROM datas INNER JOIN texts ON datas.id = texts.id"; SQLiteCommand command = new SQLiteCommand(select, connection); using (SQLiteDataReader reader = command.ExecuteReader()) InitCards(reader); command.Dispose(); } return(true); } catch (Exception) { return(false); } }
public void Open(string filePath) { if (_command != null) _command.Dispose(); if (_conn != null) _conn.Close(); try { ConnectionStringBuilder connstr = new ConnectionStringBuilder(); _conn = new Connection(); connstr.DataSource = (filePath.EndsWith("/") || filePath.EndsWith("\\")) ? filePath + "sys.db" : filePath + "/sys.db"; _conn.ConnectionString = connstr.ToString(); _conn.Open(); _command = new Command(_conn); _command.CommandText = "SELECT Content FROM [Text] WHERE [Name]=:name AND [Language]=:language"; _command.Parameters.Add(new Parameter(":name", DbType.Binary)); _command.Parameters.Add(new Parameter(":language", DbType.Binary)); } catch { if (_command != null) _command.Dispose(); if (_conn != null) _conn.Dispose(); _command = null; _conn = null; throw new DatabaseException("Cannot Open System Database"); } }
/// <summary> /// Returns all subscribed feeds. /// </summary> public IEnumerable<Feed> GetAllFeeds() { var feeds = new List<Feed>(); using (var connection = new SqliteConnection("Data Source=" + dbPath)) using (var query = new SqliteCommand("SELECT * FROM Feeds", connection)) { connection.Open(); var reader = query.ExecuteReader(CommandBehavior.CloseConnection); while (reader.Read()) { var feed = new Feed(); feed.Id = int.Parse(reader["id"].ToString()); feed.Name = reader ["name"].ToString(); feed.Url = reader ["url"].ToString(); feed.LastUpdated = DateTime.Parse (reader ["LastUpdated"].ToString ()); feed.CategoryId = int.Parse(reader["categoryId"].ToString()); feeds.Add(feed); } reader.Close(); } return feeds; }
public void Fill(int id) { ItemId = id; NewItem = false; MainClass.StatusMessage(String.Format ("Запрос выставки №{0}...", id)); string sql = "SELECT exhibition.* FROM exhibition WHERE exhibition.id = @id"; try { SqliteCommand cmd = new SqliteCommand(sql, (SqliteConnection) QSMain.ConnectionDB); cmd.Parameters.AddWithValue("@id", id); using(SqliteDataReader rdr = cmd.ExecuteReader()) { rdr.Read(); labelID.Text = rdr["id"].ToString(); entryName.Text = rdr["name"].ToString(); entryPhone1.Text = DBWorks.GetString(rdr, "phone", ""); entryPhone2.Text = DBWorks.GetString(rdr, "phone2", ""); textAddress.Buffer.Text = DBWorks.GetString(rdr, "address", ""); } MainClass.StatusMessage("Ok"); this.Title = entryName.Text; } catch (Exception ex) { QSMain.ErrorMessageWithLog(this, "Ошибка получения информации о номенклатуре!", logger, ex); } TestCanSave(); }
/// <summary> /// Returns all categories. /// </summary> public IEnumerable<Category> GetAllCategories() { var categories = new List<Category>(); using (var connection = new SqliteConnection("Data Source=" + dbPath)) using (var query = new SqliteCommand("SELECT * FROM Categories", connection)) { connection.Open(); var reader = query.ExecuteReader(CommandBehavior.CloseConnection); while (reader.Read()) { var category = new Category(); category.Id = int.Parse(reader["id"].ToString()); category.Name = reader ["name"].ToString(); categories.Add(category); } reader.Close(); } return categories; }
public IList<SyncItem> GetAll() { List<SyncItem> returnData = new List<SyncItem>(); using (var conn = _provider.GetConnection()) { conn.Open(); using (SqliteCommand command = new SqliteCommand( string.Format( @"SELECT Id, FileKey, CloudAssetId, CloudLastUpdatedDate, CloudCreatedDate, IsDeleted, Size FROM {0}", SyncItem.TableName), conn)) { var reader = command.ExecuteReader(); while (reader.Read()) { SyncItem item = new SyncItem(); item.Id = reader.GetInt32(0); item.FileKey = reader.GetString(1); item.CloudAssetId = reader.GetString(2); item.CloudLastUpdated = new DateTime(reader.GetInt64(3)); item.CloudCreated = new DateTime(reader.GetInt64(4)); item.IsDeleted = reader.GetBoolean(5); returnData.Add(item); } } conn.Close(); } return returnData; }
public GUIhosts(GUImain gui, SqliteConnection connection, SqliteCommand command) { InitializeComponent(); InitializeList(); this.gui = gui; _connection = connection; _command = command; using (_command = new SqliteCommand("SELECT host, port, password FROM hosts ORDER BY id DESC", _connection)) { using (SqliteDataReader reader = _command.ExecuteReader()) { while (reader.Read()) { String host = gui.GetSafeString(reader, 0); String port = gui.GetSafeString(reader, 1); String password = gui.GetSafeString(reader, 2); String[] items = { host, port, password }; ListViewItem item = new ListViewItem(items); list.Items.Add(item); } } } }
void addRow(string sName, string sNote) { SqliteCommand cmd=new SqliteCommand(con); cmd.CommandText= string.Format("Insert into Cars (id,name,note) VALUES(NULL,'{0}','{1}');", sName,sNote); da.InsertCommand=cmd; da.InsertCommand.ExecuteNonQuery(); DataTable dt = ds.Tables[0]; DataRow dr = dt.NewRow(); dr["name"]=sName; dr["note"]=sNote; dr["id"]=getNewID(); dt.Rows.Add(dr); System.Console.WriteLine(da.InsertCommand.CommandText); dt.AcceptChanges(); ds.AcceptChanges(); da.Update(dt); doRefresh(); }
private bool _CreateCoverDB() { try { using (var command = new SQLiteCommand(_Connection)) { command.CommandText = "CREATE TABLE IF NOT EXISTS Version (Value INTEGER NOT NULL);"; command.ExecuteNonQuery(); command.CommandText = "INSERT INTO Version (Value) VALUES(@Value)"; command.Parameters.Add("@Value", DbType.Int32).Value = CSettings.DatabaseCoverVersion; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS Cover ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + "Path TEXT NOT NULL, width INTEGER NOT NULL, height INTEGER NOT NULL);"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS CoverData ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + "CoverID INTEGER NOT NULL, Data BLOB NOT NULL);"; command.ExecuteNonQuery(); } } catch (Exception e) { CLog.LogError("Error creating Cover DB " + e); return(false); } return(true); }
public void CommitTransaction() { var lst = new List<string>(); using (var cmd = new SqliteCommand(String.Format("SELECT DISTINCT [TableName] FROM {0}", TranStatusTable), ActiveConnection)) { using (SqliteDataReader r = cmd.ExecuteReader()) { while (r.Read()) { lst.Add(r.GetString(0)); } } } SqliteTransaction tran = ActiveConnection.BeginTransaction(); try { foreach (String tableName in lst) { using (var cmd = new SqliteCommand(String.Format("DELETE FROM __{0}", tableName), tran.Connection, tran)) cmd.ExecuteNonQuery(); } using (var cmd = new SqliteCommand(String.Format("DELETE FROM {0}", TranStatusTable), tran.Connection, tran)) cmd.ExecuteNonQuery(); tran.Commit(); } catch { tran.Rollback(); throw; } }
public bool Delete(Guid presentationUID) { bool ret = false; if (presentationUID == Guid.Empty) return false; using (SqliteConnection conn = GetConnection()) { using (SqliteCommand sqlCmd = new SqliteCommand(@" BEGIN; " + "DELETE FROM presentations " + "WHERE PresentationUID=@PresentationUID;" + "COMMIT;", conn)) { sqlCmd.Parameters.AddWithValue("@PresentationUID", presentationUID.ToString()); conn.Open(); try { sqlCmd.ExecuteNonQuery(); ret = true; } catch (SqliteException ex) { Logging.Log(this, Logging.LoggingTypeError, "SQL cmd: " + sqlCmd, ex); } conn.Close(); } } return ret; }
public void NonQuery( string cmdstr ) { using (var cmd = new SqliteCommand( con )) { cmd.CommandText = cmdstr; cmd.ExecuteNonQuery(); } }
public static List<string[]> ExecuteStringCommand(SqliteCommand command, int columncount) { try { var values = new List<string[]>(); SqliteDataReader reader = command.ExecuteReader(); while (reader.Read()) { var row = new List<string>(); for (int i = 0; i < reader.FieldCount; i++) { row.Add(reader[i].ToString()); } values.Add(row.ToArray()); } reader.Close(); return values; } catch (Exception ex) { MessageBox.Show(ex.Message); return new List<string[]>(); } }
public static void Init(string databaseFullPath) { try { if (!File.Exists(databaseFullPath)) { throw new Exception("Could not find the cards database."); } _cards = new Dictionary<int, NamedCard>(); using (SqliteConnection connection = new SqliteConnection("Data Source=" + databaseFullPath)) { connection.Open(); using (IDbCommand command = new SqliteCommand( "SELECT datas.id, ot, alias, setcode, type, level, race, attribute, atk, def, texts.name, texts.desc" + " FROM datas INNER JOIN texts ON datas.id = texts.id", connection)) { using (IDataReader reader = command.ExecuteReader()) { while (reader.Read()) { LoadCard(reader); } } } } } catch (Exception ex) { throw new Exception("Could not initialize the cards database. Check the inner exception for more details.", ex); } }
public void UpdateOrders() { MainClass.StatusMessage("Получаем таблицу заказов..."); string sql = "SELECT orders.id, orders.customer, orders.contract, orders.address, orders.phone1, orders.phone2, orders.arrval, orders.deadline_s, orders.deadline_e FROM orders "; SqliteCommand cmd = new SqliteCommand(sql, (SqliteConnection) QSMain.ConnectionDB); using(SqliteDataReader rdr = cmd.ExecuteReader()) { OrdersListStore.Clear(); while (rdr.Read()) { OrdersListStore.AppendValues(rdr.GetInt32(rdr.GetOrdinal("id")), rdr["customer"].ToString(), rdr["contract"].ToString(), rdr["phone1"].ToString() + rdr["phone2"].ToString(), rdr["address"].ToString(), String.Format("{0:d}", rdr["arrval"]), DateWorks.GetDateRangeText(DBWorks.GetDateTime(rdr, "deadline_s", new DateTime()), DBWorks.GetDateTime(rdr, "deadline_e", new DateTime())) ); } } MainClass.StatusMessage("Ok"); }
private void liqviscdata() { con.Open(); string stm = "SELECT * FROM windowsdata WHERE comp='"+comppicker.SelectedItem+"' ORDER BY comp "; using (SqliteCommand cmd = new SqliteCommand(stm, con)) { using (SqliteDataReader rdr = cmd.ExecuteReader()) { while (rdr.Read()) { tcenti = double.Parse(temp.Text); tk = tcenti + 273.15; viscb =double.Parse( rdr["viscb"].ToString()); viscc = double.Parse(rdr["viscc"].ToString()); if (viscc != 0) { double visc1 = viscb * ((1 / tk) - (1 / viscc)); double viscocity = Math.Pow(10, visc1); Liqvisc.Text = viscocity.ToString(); } else { Liqvisc.Text = "0"; } } } } con.Close(); }
private void MakeSureTableExists() { using (SqliteCommand sqc = new SqliteCommand(connection)) { sqc.CommandText = "CREATE TABLE IF NOT EXISTS `Files` (`id` INTEGER NOT NULL PRIMARY KEY, `path` TEXT NOT NULL, `changedate` INTEGER NOT NULL, `size` INTEGER NOT NULL, `hash` TEXT NOT NULL)"; sqc.ExecuteNonQuery(); } }
private void _CreateHighscoreDBV1(string filePath) { using (var connection = new SQLiteConnection()) { connection.ConnectionString = "Data Source=" + filePath; try { connection.Open(); } catch (Exception) { return; } using (var command = new SQLiteCommand(connection)) { command.CommandText = "CREATE TABLE IF NOT EXISTS Version ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, Value INTEGER NOT NULL);"; command.ExecuteNonQuery(); command.CommandText = "INSERT INTO Version (id, Value) VALUES(NULL, 1 )"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS Songs ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + "Artist TEXT NOT NULL, Title TEXT NOT NULL, NumPlayed INTEGER);"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS Scores ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + "SongID INTEGER NOT NULL, PlayerName TEXT NOT NULL, Score INTEGER NOT NULL, LineNr INTEGER NOT NULL, Date BIGINT NOT NULL, " + "Medley INTEGER NOT NULL, Duet INTEGER NOT NULL, Difficulty INTEGER NOT NULL);"; command.ExecuteNonQuery(); } } }
/// <summary> /// Write or update files and hashes. /// </summary> /// <param name="liste"></param> public void WriteFiles(List<FileObject> liste) { using (SqliteTransaction sqt = connection.BeginTransaction()) { using (SqliteCommand sqc = new SqliteCommand(connection)) { // Alle vorhandenen Einträge löschen, da diese in jedem Fall überschrieben werden sollten sqc.CommandText = "DELETE FROM Files WHERE path=:path"; sqc.Parameters.Add(new SqliteParameter("path")); foreach (FileObject d in liste) { sqc.Parameters["path"].Value = d.Filepath; sqc.ExecuteNonQuery(); } //sqc.Parameters.Clear(); // Nötig? // Dateien eintragen sqc.CommandText = "INSERT INTO Files (path, hash, size, changedate) VALUES (:path, :hash, :size, :changedate)"; sqc.Parameters.Add(new SqliteParameter("path")); sqc.Parameters.Add(new SqliteParameter("hash")); sqc.Parameters.Add(new SqliteParameter("size")); sqc.Parameters.Add(new SqliteParameter("changedate")); foreach (FileObject d in liste) { sqc.Parameters["path"].Value = d.Filepath; sqc.Parameters["hash"].Value = d.Hash; sqc.Parameters["size"].Value = d.Size; sqc.Parameters["changedate"].Value = d.ChangeDate; sqc.ExecuteNonQuery(); } } sqt.Commit(); } }
public static List<Dictionary<string, string>> QueryImpl(string handler, string statement, string[] param) { List<Dictionary<string,string>> result = new List<Dictionary<string,string>>(); var db = dbs[handler]; var dbcmd = new SqliteCommand(ConvertStatment(statement), db); // Hard and ugly hack to use '?' for (var i = 1; i <= param.Length; i++) { dbcmd.Parameters.AddWithValue("@a" + i, param[i-1]); } IDataReader reader = dbcmd.ExecuteReader(); while(reader.Read()) { Dictionary<string,string> row = new Dictionary<string,string>(); for (var i = 0; i < reader.FieldCount; i++) { string val = reader.GetValue(i).ToString(); row.Add(reader.GetName(i),val); } result.Add(row); } reader.Dispose(); dbcmd.Dispose(); return result; }
public override bool addWorker(string fname, string lname, string village, string hnr, int plz, string email, string mobile, string tel, string street) { try { sqlite_cmd = sqlite_conn.CreateCommand (); sqlite_cmd.CommandText = "INSERT INTO tbl_worker (fname, lname, hnr, PLZ, village, email, mobile, telephone, street) VALUES ('"+fname+"', '"+lname+"','"+hnr+"','"+plz+"','"+village+"','"+email+"','"+mobile+"','"+tel+"','"+street+"')"; sqlite_conn.Open(); sqlite_cmd.ExecuteNonQuery(); sqlite_conn.Close(); int WorkerID = this.readWorkerID(fname,lname,village,hnr,email); if(WorkerID != 0) { return true; } else { return false; } } catch (Exception ex) { sqlite_conn.Close (); return false; } }
//Update from V0 (empty) to V1 private bool _UpdateV1() { if (_Connection == null || _Version >= 1) return false; using (SQLiteTransaction transaction = _Connection.BeginTransaction()) { try { foreach (string file in _FilesV1) { string filePath = Path.Combine(CSettings.ProgramFolder, file); if (!_AddImageToCreditsDB(filePath, transaction)) { transaction.Rollback(); return false; } } using (SQLiteCommand command = new SQLiteCommand(_Connection)) { command.Transaction = transaction; command.CommandText = "Update Version SET Value=@Value)"; command.Parameters.Add("@Value", DbType.Int32).Value = 1; command.ExecuteNonQuery(); } transaction.Commit(); } catch (Exception) { transaction.Rollback(); return false; } } return true; }
public static int DoNonQuery (SqliteConnection connection, string command_text, string[] param_names, object[] param_args) { int ret = 0; using (SqliteCommand command = new SqliteCommand ()) { command.Connection = connection; command.CommandText = command_text; if (param_names != null) { if (param_args == null || param_names.Length != param_args.Length) throw new ArgumentException ("param_names, param_args", "param_names and param_args should have same number of items"); for (int i = 0; i < param_names.Length; ++i) command.Parameters.AddWithValue (param_names [i], param_args [i]); } while (true) { try { ret = command.ExecuteNonQuery (); break; } catch (SqliteException e) { if (e.ErrorCode == SQLiteErrorCode.Busy) { Thread.Sleep (50); } else { throw; } } catch (Exception e) { Log.Error (e, "SQL that caused the exception: {0}", command_text); throw; } } } return ret; }
public void DataCount(string table_name,out int count) { count=0; DbCommand = DbConnection.CreateCommand(); DbCommand.CommandText = "SELECT COUNT(*) FROM " + table_name; count = System.Convert.ToInt32(DbCommand.ExecuteScalar()); }
static List<Dictionary<string, object>> ExecuteQuery(string query, List<SqliteParameter> pars) { List<Dictionary<string, object>> res = new List<Dictionary<string, object>>(); using (var Conn = GetConnection()) { Conn.Open(); using (SqliteCommand command = new SqliteCommand(query, Conn)) { foreach (var par in pars) command.Parameters.Add(par); using (var reader = command.ExecuteReader()) { if (reader.HasRows) { while (reader.Read()) { res.Add(new Dictionary<string, object>()); for (int i = 0; i < reader.FieldCount; i++) { res[res.Count - 1][reader.GetName(i)] = reader[i]; } } } } } } return res; }
public void RoomInfo(Socket UserSocket, SQLiteConnection connection, Dictionary <Socket, Character> clientDictonary) { ASCIIEncoding encoder = new ASCIIEncoding(); string returnMessage = ""; Character character = clientDictonary[UserSocket]; command = new sqliteCommand("select * from " + "table_characters" + " where name = " + "'" + character.name + "'", connection); var characterSearch = command.ExecuteReader(); while (characterSearch.Read()) { command = new sqliteCommand("select * from " + "table_dungeon" + " where name = " + "'" + characterSearch["room"] + "'", connection); } characterSearch.Close(); var dungeonSearch = command.ExecuteReader(); while (dungeonSearch.Read()) { returnMessage += "-------------------------------"; returnMessage += "\nName: " + dungeonSearch["name"]; returnMessage += "\nDescription: " + dungeonSearch["description"]; returnMessage += "\nNorth: " + dungeonSearch["North"]; returnMessage += "\nSouth: " + dungeonSearch["South"]; returnMessage += "\nEast: " + dungeonSearch["East"]; returnMessage += "\nWest: " + dungeonSearch["West"]; returnMessage += "\nUp: " + dungeonSearch["Up"]; returnMessage += "\nDown: " + dungeonSearch["Down"]; returnMessage += "\n-------------------------------"; } connection.Close(); byte[] sendbuffer = encoder.GetBytes(returnMessage); int bytesSent = UserSocket.Send(sendbuffer); //try //{ // Console.WriteLine(""); // command = new sqliteCommand("select * from " + "table_dungeon" + " order by name asc", connection); // var reader = command.ExecuteReader(); // while (reader.Read()) // { // Console.WriteLine("Name: " + reader["name"]); // } // reader.Close(); // Console.WriteLine(""); //} //catch (Exception ex) //{ // Console.WriteLine("Failed to display DB" + ex); //} }
public void AddUser(string username) { string insertuser = "******"" + username + "\");"; //Console.WriteLine(insertuser); cmd = dbConnection.CreateCommand(); cmd.CommandText = insertuser; cmd.ExecuteNonQuery(); }
static void clientReceiveThread(object obj) { ReceiveThreadLaunchInfo receiveInfo = obj as ReceiveThreadLaunchInfo; bool socketactive = true; socketToCharacter.Add(receiveInfo.socket, receiveInfo.clientCharacter); var sql = "insert into " + "table_characters" + " (name, room) values"; sql += "('" + receiveInfo.clientCharacter.name + "'"; sql += ","; sql += "'" + receiveInfo.clientCharacter.playerRoom + "'"; sql += ")"; SQLiteCommand command = new sqliteCommand(sql, connection); try { command.ExecuteNonQuery(); } catch { Console.WriteLine("Failed to perform simple addition but still did it anyway."); } MudowRun.RoomInfo(receiveInfo.socket, connection, socketToCharacter); while ((active == true) && (socketactive == true)) { byte[] buffer = new byte[4094]; try { int result = receiveInfo.socket.Receive(buffer); if (result > 0) { ASCIIEncoding encoder = new ASCIIEncoding(); lock (incommingMessages) { string message = encoder.GetString(buffer, 0, result); if (receiveInfo.clientCharacter.PlayerLoginDetails(receiveInfo.userState, message, connection) == false) { MudowRun.Process(receiveInfo.clientCharacter, message, receiveInfo.socket, socketToCharacter, connection); } MudowRun.RoomInfo(receiveInfo.socket, connection, socketToCharacter); } } } catch (System.Exception ex) { socketactive = false; } } }
//depending on what the client sent (1 or 2) add a username to databse or retreive a name from the database static bool username(string Key, Socket client) { int bytesSent; ASCIIEncoding encoder = new ASCIIEncoding(); sqliteCommand command; var input = Key.Split(' '); switch (input[0]) { case "1": for (int i = 1; i < input.Length; i++) { name += input[i]; } try { var sql = "insert into " + "table_usernames" + " (name) values "; sql += "('" + name + "'"; sql += ")"; command = new sqliteCommand(sql, conn); command.ExecuteNonQuery(); } catch (Exception ex) { Console.WriteLine("Failed to add: " + name + " : to DB " + ex); } return(true); case "2": for (int i = 1; i < input.Length; i++) { name += input[i]; } try { command = new sqliteCommand("select * from table_usernames where name == '" + name + "'", conn); var reader = command.ExecuteReader(); if (reader.HasRows == true) { byte[] sendBuffer = encoder.GetBytes("signed in"); bytesSent = client.Send(sendBuffer); } } catch (Exception ex) { Console.WriteLine("Failed to find: " + name + " : to DB " + ex); } return(true); } return(false); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); DataTable dtArtists = new DataTable(); #region fetch data for artists Mono.Data.Sqlite.SqliteConnection cn = new Mono.Data.Sqlite.SqliteConnection("library.sqlite"); Mono.Data.Sqlite.SqliteCommand comm = new Mono.Data.Sqlite.SqliteCommand(cn); Mono.Data.Sqlite.SqliteDataAdapter adapter = new Mono.Data.Sqlite.SqliteDataAdapter(comm); comm.CommandText = @" SELECT name, id, fetched FROM artists "; adapter.Fill(dtArtists); #endregion if (dtArtists.Rows.Count == 0) { List <SubsonicItem> artists = Subsonic.GetIndexes(); foreach (SubsonicItem artist in artists) { DataRow dr = dtArtists.NewRow(); dr["name"] = artist.name; dr["id"] = artist.id; dr["feteched"] = DateTime.Now.ToString(); dtArtists.Rows.Add(dr); comm = new Mono.Data.Sqlite.SqliteCommand(cn); comm.CommandText = @" INSERT INTO artists (name, id, fetched) VALUES(@name, @id, @fetched); "; comm.Parameters.AddWithValue("@name", artist.name); comm.Parameters.AddWithValue("@id", artist.id); comm.Parameters.AddWithValue("@fetched", DateTime.Now.ToString()); if (cn.State != ConnectionState.Open) { cn.Open(); } comm.ExecuteNonQuery(); } if (cn.State != ConnectionState.Closed) { cn.Close(); } } rptArtists.DataSource = dtArtists; rptArtists.DataBind(); }
private bool _ConvertV2toV3(SQLiteConnection connection) { var command = new SQLiteCommand(connection) { CommandText = "ALTER TABLE Songs ADD DateAdded BIGINT" }; command.ExecuteNonQuery(); command.CommandText = "UPDATE Songs SET [DateAdded] = @DateAdded"; command.Parameters.Add("@DateAdded", DbType.Int64, 0).Value = DateTime.Now.Ticks; command.ExecuteNonQuery(); command.CommandText = "UPDATE Version SET [Value] = @version"; command.Parameters.Add("@version", DbType.Int32, 0).Value = 3; command.ExecuteNonQuery(); //Read NumPlayed from Scores and save to Songs command.CommandText = "SELECT SongID, Date FROM Scores ORDER BY Date ASC"; SQLiteDataReader reader; try { reader = command.ExecuteReader(); } catch (Exception) { return(false); } long lastDateAdded = -1; int lastID = -1; DateTime dt = new DateTime(1, 1, 1, 0, 0, 5); long sec = dt.Ticks; List <int> ids = new List <int>(); while (reader.Read()) { int id = reader.GetInt32(0); long dateAdded = reader.GetInt64(1); if (id != lastID || dateAdded > lastDateAdded + sec) { ids.Add(id); lastID = id; lastDateAdded = dateAdded; } } reader.Dispose(); foreach (int id in ids) { _IncreaseSongCounter(id, command); } command.Dispose(); return(true); }
/* * Sets the field with the int data for the entry where 'id' == id */ public void setFieldFromID(int id, int data, String field) { sqliteCommand command = new sqliteCommand("update " + m_TableName + " set " + field + " = @data where id = @id", m_Connection); command.Parameters.Add("@id", System.Data.DbType.UInt32).Value = id; command.Parameters.Add("@data", System.Data.DbType.UInt32).Value = data; command.Parameters.Add("@field", System.Data.DbType.String).Value = field; command.ExecuteNonQuery(); }
/* * Sets the field with the String data for the entry where 'name' == name */ public void setFieldFromName(String name, String data, String field) { sqliteCommand command = new sqliteCommand("update " + m_TableName + " set " + field + " = @data where name = @name", m_Connection); command.Parameters.Add("@data", System.Data.DbType.String).Value = data; command.Parameters.Add("@name", System.Data.DbType.String).Value = name; command.Parameters.Add("@field", System.Data.DbType.String).Value = field; command.ExecuteNonQuery(); }
private bool _GetDataBaseSongInfos(int songID, out string artist, out string title, out int numPlayed, out DateTime dateAdded, string filePath) { artist = String.Empty; title = String.Empty; numPlayed = 0; dateAdded = DateTime.Today; using (var connection = new SQLiteConnection()) { connection.ConnectionString = "Data Source=" + filePath; try { connection.Open(); } catch (Exception) { return(false); } using (var command = new SQLiteCommand(connection)) { command.CommandText = "SELECT Artist, Title, NumPlayed, DateAdded FROM Songs WHERE [id] = @id"; command.Parameters.Add("@id", DbType.String, 0).Value = songID; SQLiteDataReader reader; try { reader = command.ExecuteReader(); } catch (Exception) { return(false); } if (reader != null && reader.HasRows) { reader.Read(); artist = reader.GetString(0); title = reader.GetString(1); numPlayed = reader.GetInt32(2); dateAdded = new DateTime(reader.GetInt64(3)); reader.Dispose(); return(true); } if (reader != null) { reader.Dispose(); } } } return(false); }
public bool queryExists(String query, String field) { sqliteCommand command = new sqliteCommand("select * from " + m_TableName + " where " + field + " = @query", m_Connection); command.Parameters.Add("@query", System.Data.DbType.String).Value = query; command.Parameters.Add("@field", System.Data.DbType.String).Value = field; sqliteDataReader reader = command.ExecuteReader(); return(reader.HasRows); }
private int _GetDataBaseSongID(int songID, SQLiteCommand command) { CSong song = CSongs.GetSong(songID); if (song == null) { return(-1); } return(_GetDataBaseSongID(song.Artist, song.Title, 0, command)); }
//sets players in room and where they can move to public void SetClientInRoom(Socket client, String room) { if (socketToRoomLookup.ContainsKey(client) == false) { var command = new sqliteCommand("select * from table_rooms where name == '" + room + "'", conn); var reader = command.ExecuteReader(); reader.Read(); Room currentRoom = new Room(reader["name"] as String, reader["desc"] as String); socketToRoomLookup[client] = currentRoom; } }
public static bool SaveToDB(string dataSource, string completeQuery) { using (SqliteConnection con = new SqliteConnection()) { con.ConnectionString = dataSource; try { con.Open(); } catch (Exception ex) { MakeLogErrorStatic(typeof(DBReader), ex); if (con.State.ToString() == "Open") { con.Close(); con.Dispose(); } return(false); } // security check and close connection if necessary if (!DBSecurity.IsSecureSQLCommand(completeQuery)) { MakeLogWarningStatic(typeof(DBReader), "SaveToDB: Prevented forwarding of insecure sql-command: " + completeQuery); return(false); } using (SQLiteCommand cmd = new SQLiteCommand(completeQuery, con)) { cmd.CommandText = completeQuery; SQLiteDataReader rdr = null; try { cmd.ExecuteReader(); } catch (Exception ex) { throw new Exception("Could not execute SQLiteDataReader in SaveToDB: " + ex); } finally { if (rdr != null) { rdr.Close(); } } } } return(true); }
public override void update(ActionTimer timer) { using (SQLiteCommand command = new SQLiteCommand(Sqlite.getSqlite().connection)) { command.CommandText = "SELECT name FROM `account` WHERE `id`=@id"; command.Parameters.AddWithValue("@id", this.accID); using (SQLiteDataReader sdrITM = command.ExecuteReader()) { if (sdrITM.HasRows) { sdrITM.Read(); this.name = Convert.ToString(sdrITM["name"]); accExists = true; } } } if (accExists) { using (SQLiteCommand command = new SQLiteCommand(Accounts.Logs.SQLiteLogger.connection)) { command.CommandText = "SELECT * FROM `logStats` WHERE `accountID`=@id"; command.Parameters.AddWithValue("@id", this.accID); using (SQLiteDataReader sdrITM = command.ExecuteReader()) { if (sdrITM.HasRows) { List <AccountLogChar> alcList = new List <AccountLogChar>(); while (sdrITM.Read()) { AccountLogChar alc = new AccountLogChar(); alc.type = Convert.ToInt32(sdrITM["type"]); alc.value = Convert.ToInt32(sdrITM["value"]); alc.time = Convert.ToInt64(sdrITM["time"]); alcList.Add(alc); } charStatList = alcList.ToArray(); } } } } isFinished = true; timer.removeAction(this); }
public void CreateStandardTables() { SQLiteCommand command = new SQLiteCommand(connection); command.CommandText = "CREATE TABLE IF NOT EXISTS `world_container` ("; command.CommandText += " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"; command.CommandText += " `name` text NOT NULL,"; command.CommandText += " `posx` REAL NOT NULL,"; command.CommandText += " `posy` REAL NOT NULL,"; command.CommandText += " `posz` REAL NOT NULL,"; command.CommandText += " `world` text NOT NULL,"; command.CommandText += " `opened` INTEGER NOT NULL"; command.CommandText += ")"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS `world_items` ("; command.CommandText += " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"; command.CommandText += " `iteminstance` text NOT NULL,"; command.CommandText += " `amount` INTEGER NOT NULL,"; command.CommandText += " `posx` REAL NOT NULL,"; command.CommandText += " `posy` REAL NOT NULL,"; command.CommandText += " `posz` REAL NOT NULL,"; command.CommandText += " `world` text NOT NULL"; command.CommandText += ")"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS `world_mobinteract` ("; command.CommandText += " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"; command.CommandText += " `vobType` INTEGER NOT NULL,"; command.CommandText += " `name` text NOT NULL,"; command.CommandText += " `posx` REAL NOT NULL,"; command.CommandText += " `posy` REAL NOT NULL,"; command.CommandText += " `posz` REAL NOT NULL,"; command.CommandText += " `world` text NOT NULL,"; command.CommandText += " `triggered` INTEGER NOT NULL"; command.CommandText += ")"; command.ExecuteNonQuery(); command.CommandText = "CREATE TABLE IF NOT EXISTS `world_container_items` ("; command.CommandText += " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"; command.CommandText += " `containerid` INTEGER NOT NULL,"; command.CommandText += " `item` text NOT NULL,"; command.CommandText += " `amount` INTEGER NOT NULL"; command.CommandText += ")"; command.ExecuteNonQuery(); command.Dispose(); }