bookmark-manager/RyzStudio/Data/SQLite/SQLiteDatabase2.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SQLite;
using System.IO;
using System.Text;

namespace RyzStudio.Data.SQLite
{
	public class SQLiteDatabase2
	{
		public SQLiteConnection DBConnection { get; protected set; } = null;

		public string DBLocation { get; protected set; } = null;

		public string LastError { get; protected set; } = null;

		public int LastInsertID
		{
			get
			{
				if (this.DBConnection == null)
				{
					return 0;
				}

				DataTable dt = this.DoQuery("SELECT last_insert_rowid() AS rv;");
				if (dt == null)
				{
					return 0;
				}

				if (dt.Rows.Count <= 0)
				{
					return 0;
				}

				int n;
				if (!int.TryParse(dt.Rows[0]["rv"].ToString(), out n))
				{
					n = 0;
				}

				return n;
			}
		}

		protected string[] requiredTableList = new string[0];

		protected const string appSettingsTableName = "ryz_app_xxxx_config";

		public bool Create()
		{
			this.LastError = string.Empty;

			this.DBLocation = ":memory:";

			try
			{
				this.DBConnection = new SQLiteConnection(string.Concat("Data Source=\"", this.DBLocation, "\";Version=3;UTF8Encoding=True;"));
				this.DBConnection.Open();
			}
			catch (Exception exc)
			{
				this.LastError = exc.Message;

				return false;
			}

			return true;
		}

		public bool Create(string filename, bool overwriteFile = false, string password = null, bool useAppSettings = false)
		{
			bool rs = create(filename, overwriteFile, password);

			if (useAppSettings)
			{
				if (!rs)
				{
					return false;
				}

				rs = prepareDatabase();
				if (!rs)
				{
					return false;
				}

				return this.HasRequiredTables();
			}
			else
			{
				return rs;
			}
		}

		public bool LoadFile(string filename, string password = null)
		{
			this.LastError = string.Empty;

			if (!File.Exists(filename))
			{
				return false;
			}

			this.DBLocation = filename;

			try
			{
				this.DBConnection = new SQLiteConnection(string.Concat("Data Source=\"", filename, "\";Version=3;UTF8Encoding=True;", (password == null) ? string.Empty : string.Concat("Password=", encode64(password), ";")));
				this.DBConnection.Open();
			}
			catch (Exception exc)
			{
				this.LastError = exc.Message;

				return false;
			}

			return true;
		}

		public void Close()
		{
			this.LastError = string.Empty;

			if (this.DBConnection != null)
			{
				try
				{
					this.DBConnection.Cancel();
					this.DBConnection.Close();
					this.DBConnection.Dispose();
					this.DBConnection = null;

					SQLiteConnection.ClearAllPools();
					GC.Collect();
				}
				catch (Exception exc)
				{
					this.LastError = exc.Message;
				}
			}
		}

		public DataTable DoQuery(string query)
		{
			this.LastError = string.Empty;

			if (this.DBConnection == null)
			{
				return null;
			}

			try
			{
				SQLiteCommand command = new SQLiteCommand(query, this.DBConnection);
				SQLiteDataReader dr = command.ExecuteReader();

				DataTable dt = new DataTable();
				dt.Load(dr);

				return dt;
			}
			catch (Exception exc)
			{
				this.LastError = exc.Message;

				return null;
			}
		}

		public DataTable DoQuery(string query, params string[] args) => DoQuery(prepareQuery(query, args));

		public int DoQueryCount(string query)
		{
			this.LastError = string.Empty;

			if (this.DBConnection == null)
			{
				return -1;
			}

			DataTable dt = this.DoQuery(query);
			if (dt == null)
			{
				return -1;
			}

			return dt.Rows.Count;
		}

		public int DoQueryCount(string query, params string[] args) => this.DoQueryCount(prepareQuery(query, args));

		public bool DoQueryExist(string query) => (this.DoQueryCount(query) > 0);

		public bool DoQueryExist(string query, params string[] args) => this.DoQueryExist(prepareQuery(query, args));

		public string DoQuerySingle(string query)
		{
			this.LastError = string.Empty;

			if (this.DBConnection == null)
			{
				return string.Empty;
			}

			DataTable dt = this.DoQuery(query);

			if (dt == null)
			{
				return string.Empty;
			}

			if (dt.Columns.Count <= 0)
			{
				return string.Empty;
			}

			if (dt.Rows.Count <= 0)
			{
				return string.Empty;
			}

			if (dt.Rows[0][0] is byte[])
			{
				return Encoding.UTF8.GetString(dt.Rows[0][0] as byte[]);
			}
			else
			{
				return dt.Rows[0][0].ToString();
			}
		}

		public string DoQuerySingle(string query, params string[] args) => this.DoQuerySingle(prepareQuery(query, args));

		public int DoNonQuery(string query)
		{
			this.LastError = string.Empty;

			if (this.DBConnection == null)
			{
				return -1;
			}

			int rv = 0;

			try
			{
				SQLiteCommand command = new SQLiteCommand(query, this.DBConnection);
				rv = command.ExecuteNonQuery();
			}
			catch (Exception exc)
			{
				this.LastError = exc.Message;
				rv = -1;
			}

			return rv;
		}

		public int DoNonQuery(string query, params string[] args) => this.DoNonQuery(prepareQuery(query, args));

		public bool HasTable(string tableName)
		{
			this.LastError = string.Empty;

			if (this.DBConnection == null)
			{
				return false;
			}

			int rv = this.DoQueryCount("SELECT 1 FROM sqlite_master WHERE type='table' AND name='" + escapeSQL(tableName) + "'");

			return (rv > 0);
		}

		public bool HasRequiredTables()
		{
			bool rv = true;
			foreach (string tbl in requiredTableList)
			{
				if (string.IsNullOrEmpty(tbl))
				{
					continue;
				}

				if (!this.HasTable(tbl))
				{
					rv = false;
					break;
				}
			}

			return rv;
		}

		public bool SetConfig(string name, bool value) => this.SetConfig(name, (value ? "1" : "0"));

		public bool SetConfig(string name, int value) => this.SetConfig(name, value.ToString());

		public bool SetConfig(string name, string value)
		{
			prepareAppSettings();

			string sql = string.Empty;
			int rv = this.DoQueryCount("SELECT 1 FROM " + appSettingsTableName + " WHERE cfg_name='" + escapeSQL(name) + "'");
			if (rv <= 0)
			{
				sql = "INSERT INTO " + appSettingsTableName + " (cfg_name, cfg_value) VALUES ('[^1]', '[^2]');";
			}
			else
			{
				sql = "UPDATE " + appSettingsTableName + " SET cfg_value='[^2]' WHERE cfg_name='[^1]';";
			}

			sql = prepareQuery(sql, new string[] { name, value });

			return this.DoNonQuery(sql) > 0;
		}

		public string GetConfig(string name, string defaultValue = null)
		{
			prepareAppSettings();

			bool rv = this.DoQueryExist("SELECT 1 FROM " + appSettingsTableName + " WHERE cfg_name='" + escapeSQL(name) + "';");
			if (!rv)
			{
				return defaultValue;
			}

			return this.DoQuerySingle("SELECT cfg_value FROM " + appSettingsTableName + " WHERE cfg_name='" + escapeSQL(name) + "';");
		}

		public int GetIntConfig(string name, int defaultValue = 0)
		{
			string rv = this.GetConfig(name);
			if (string.IsNullOrWhiteSpace(rv))
			{
				return defaultValue;
			}

			int n;
			if (!int.TryParse(rv, out n))
			{
				n = defaultValue;
			}

			return n;
		}

		public bool GetBoolConfig(string name, bool defaultValue = false)
		{
			string rv = this.GetConfig(name);
			if (string.IsNullOrWhiteSpace(rv))
			{
				return defaultValue;
			}

			if (rv.Equals("1"))
			{
				return true;
			}

			if (rv.Equals("true", StringComparison.CurrentCultureIgnoreCase))
			{
				return true;
			}

			return false;
		}

		protected bool create(string filename, bool overwriteFile, string password)
		{
			this.LastError = string.Empty;

			if (File.Exists(filename))
			{
				if (overwriteFile)
				{
					try
					{
						File.Delete(filename);
					}
					catch (Exception exc)
					{
						this.LastError = exc.Message;

						return false;
					}

					try
					{
						SQLiteConnection.CreateFile(filename);
					}
					catch (Exception exc)
					{
						this.LastError = exc.Message;

						return false;
					}

					return this.LoadFile(filename, password);
				}
				else
				{
					return this.LoadFile(filename, password);
				}
			}
			else
			{
				try
				{
					SQLiteConnection.CreateFile(filename);
				}
				catch (Exception exc)
				{
					this.LastError = exc.Message;

					return false;
				}

				return this.LoadFile(filename, password);
			}
		}

		protected string prepareQuery(string query, params string[] arguments)
		{
			string rv = query;

			if (string.IsNullOrWhiteSpace(rv))
			{
				return string.Empty;
			}

			for (int i = 0; i < arguments.Length; i++)
			{
				rv = rv.Replace("[^" + (i + 1).ToString() + "]", escapeSQL(arguments[i]));
			}

			return rv;
		}

		protected string escapeSQL(string q) => q.Replace("'", "''").Trim();

		protected string escapeValue(string text) => text.Replace("\"", "\\\"").Replace("\t", "\\t").Replace("\r", " \\r").Replace("\n", "\\n");

		protected string encode64(string text) => Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(text));

		protected bool prepareAppSettings()
		{
			if (this.HasTable(appSettingsTableName))
			{
				return true;
			}

			int rv = this.DoNonQuery("CREATE TABLE " + appSettingsTableName + " (cfg_name TEXT, cfg_value TEXT)");

			return rv > 0;
		}

		protected virtual bool prepareDatabase()
		{
			return true;
		}
	}
}