470 lines
10 KiB
C#
470 lines
10 KiB
C#
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 SQLiteDatabase
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|