public void cnc(string arg)
{
if (arg == "cnc")
{
TerminalEcho("cnc: Namespace of connection commands.\n\nParameters;\n" +
"\n-c Database path: Connect.\n-c Database path,Password: Connect.\n-d: Disconnect.");
}
else if (arg.Contains("cnc -c "))
{
string rInput = arg.Substring(7).Trim();
string[] cmmd = rInput.Split(',');
string password = "";
if (cmmd.Length == 2)
{
password = cmmd[1];
}
try {
Database = new MochaDatabase(cmmd[0], password);
} catch (Exception Excep) {
TerminalErrorEcho(Excep.Message);
}
}
else if (arg == "cnc -d")
{
Database = null;
}
else
{
AddInput(new TerminalInput(CurrentTitle.Base, "Command is not found!", Color.Red, BaseFont, InputFont), false);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="db">Database.</param>
/// <param name="tableName">Name of table.</param>
/// <param name="columnName">Name of column.</param>
public ColumnEdit_Dialog(MochaDatabase db, string tableName, string columnName)
{
Database = db;
TableName = tableName;
ColumnName = columnName;
Init();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="db">Database.</param>
/// <param name="tableName">Name of table.</param>
public TableEdit_Dialog(MochaDatabase db, string tableName)
{
Database = db;
TableName = tableName;
Init();
refresContent();
}
/// <summary>
/// Create new MochaScriptDebugger.
/// </summary>
/// <param name="path">Path of MochaScript file.</param>
public MochaScriptDebugger(string path)
{
codeProcessor = new MochaScriptCodeProcessor();
ScriptPath = path;
db = null;
functions = new MochaScriptFunctionCollection(this);
compilerEvents = new MochaScriptFunctionCollection(this);
variables = new MochaScriptVariableCollection();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="database">Target database.</param>
public cncpanel(MochaDatabase database)
: this()
{
Database = database;
Database.Changed += Database_Changed;
term.Database = Database;
refreshDashboard();
refreshExplorer();
}
private void CreateButton_Click(object sender, EventArgs e)
{
bool ok = true;
string name = nameTB.Text.TrimStart();
if (string.IsNullOrEmpty(name))
{
nameTB.BorderColor = Color.Red;
ok = false;
}
if (string.IsNullOrEmpty(pathTB.Text))
{
pathTB.BorderColor = Color.Red;
ok = false;
}
if (!ok)
{
return;
}
string path = fs.Combine(pathTB.Text, name);
if (fs.ExistsFile(path + ".mhdb"))
{
errorbox.Show(
$@"[MochaDB-Studio]
A database with this name already exists on this path.");
return;
}
try {
MochaDatabase.CreateMochaDB(path, descriptionTB.Text, passwordTB.Text);
MochaDatabase db = new MochaDatabase($"path={path}; password={passwordTB.Text};logs=false;AutoConnect=true");
var connectionPanel = new cncpanel(db);
CNCList.AddItem(new sbutton()
{
Text = name, Tag = connectionPanel
});
Close();
} catch (MochaException excep) {
if (excep.Message == "The password did not meet the password conventions!")
{
passwordTB.BorderColor = Color.Red;
}
errorbox.Show("[MochaException]\n" + excep.Message);
} catch (Exception excep) {
errorbox.Show("[Exception]\n" + excep.Message + excep);
}
}
/// <summary>
/// Create a new MochaDbCommand.
/// </summary>
/// <param name="db">Target MochaDatabase.</param>
public MochaDbCommand(MochaDatabase db)
{
//Load mhql core.
USE = new Mhql_USE(Database);
SELECT = new Mhql_SELECT(Database);
RETURN = new Mhql_RETURN(Database);
ORDERBY = new Mhql_ORDERBY(Database);
GROUPBY = new Mhql_GROUPBY(Database);
MUST = new Mhql_MUST(Database);
REMOVE = new Mhql_REMOVE(Database);
keywords = new MochaArray <MhqlKeyword>(USE, SELECT, REMOVE, RETURN, ORDERBY, GROUPBY, MUST);
Database = db;
Command = string.Empty;
}
/// <summary>
/// Process in keyword.
/// </summary>
/// <param name="tdb">Target database.</param>
/// <param name="command">Command.</param>
/// <param name="table">Destination table.</param>
/// <param name="row">Destination row.</param>
/// <param name="from">Use state of FROM keyword.</param>
/// <param name="inmode">Set true if command is execute as in mode, set false if ineq mode.</param>
/// <returns>True if subquery is success, false if not.</returns>
public static bool Process(MochaDatabase tdb, string command, MochaTableResult table, MochaRow row,
bool from, bool inmode)
{
command = command.Substring(inmode ? 2 : 4).TrimStart();
int obrace = command.IndexOf(Mhql_LEXER.LBRACE);
if (obrace == -1)
{
throw new Exception($"{Mhql_LEXER.LBRACE} is not found!");
}
MochaColumn column = table.Columns[Mhql_GRAMMAR.GetIndexOfColumn(
command.Substring(0, obrace).Trim(), table.Columns, from)];
MochaTableResult result = new MochaDbCommand(tdb).ExecuteScalar(Mhql_LEXER.RangeSubqueryBrace(
command.Substring(obrace)));
if (result.Columns.Length != 1)
{
throw new Exception("Subqueries should only return one column!");
}
else if (MochaData.IsNumericType(column.DataType) != MochaData.IsNumericType(result.Columns[0].DataType) &&
column.DataType != result.Columns[0].DataType)
{
throw new Exception("Column data type is not same of subquery result!");
}
if (inmode)
{
for (int index = 0; index < row.Datas.Count; ++index)
{
for (int rindex = 0; rindex < result.Columns[0].Datas.Count; ++rindex)
{
if (row.Datas[index].Data.ToString() == result.Columns[0].Datas[rindex].Data.ToString())
{
return(true);
}
}
}
return(false);
}
else
{
if (result.Rows.Length != 1)
{
return(false);
}
return(row.Datas[0].Data.ToString() == result.Columns[0].Datas[0].Data.ToString());
}
}
private void ConnectButton_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(pathTB.Text))
{
pathTB.BorderColor = Color.Red;
return;
}
MochaDatabase db = null;
try {
db = new MochaDatabase($@"
AutoConnect=True; Path={pathTB.Text};
Password={passwordTB.Text};
Logs={logToggle.Checked}");
var connectionPanel = new cncpanel(db);
CNCList.AddItem(new sbutton()
{
Text = fs.GetFileNameFromPath(pathTB.Text), Tag = connectionPanel
});
Close();
} catch (MochaException excep) {
if (db != null)
{
db.Dispose();
}
if (excep.Message == "MochaDB database password does not match the password specified!" ||
excep.Message == "The MochaDB database is password protected!")
{
passwordTB.BorderColor = Color.Red;
}
else
{
errorbox.Show("[MochaException]\n" + excep.Message);
}
} catch (Exception excep) {
if (db != null)
{
db.Dispose();
}
errorbox.Show("[Exception]\n" + excep.Message + excep);
}
}
/// <summary>
/// Create a new MochaDbCommand.
/// </summary>
/// <param name="db">Target MochaDatabase.</param>
public MochaDbCommand(MochaDatabase db)
{
//Load mhql core.
USE = new Mhql_USE(Database);
ORDERBY = new Mhql_ORDERBY(Database);
GROUPBY = new Mhql_GROUPBY(Database);
MUST = new Mhql_MUST(Database);
REMOVE = new Mhql_REMOVE(Database);
SUBROW = new Mhql_SUBROW(Database);
SUBCOL = new Mhql_SUBCOL(Database);
DELROW = new Mhql_DELROW(Database);
DELCOL = new Mhql_DELCOL(Database);
ADDROW = new Mhql_ADDROW(Database);
CORDERBY = new Mhql_CORDERBY(Database);
keywords = new MhqlKeyword[] {
USE, REMOVE, ORDERBY, GROUPBY, MUST, SUBROW,
SUBCOL, DELROW, DELCOL, ADDROW, CORDERBY
};
Database = db;
Command = string.Empty;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="db">Database.</param>
public resultPanel(MochaDatabase db)
{
Database = db;
Init();
}
/// <summary>
/// Detect command type and execute. Returns result if exists returned result.
/// </summary>
/// <param name="mochaQ">MochaQ to be set as the active MochaQ Query.</param>
public IMochaResult ExecuteCommand(MochaDatabase database, string mochaQ)
{
Database = database;
MochaQ = mochaQ;
return(ExecuteCommand());
}
/// <summary>
/// Runs the active MochaQ query. Returns the incoming value.
/// </summary>
/// <param name="database">MochaDatabase object that provides management of the targeted MochaDB database.</param>
/// <param name="mochaQ">MochaQ to be set as the active MochaQ Query.</param>
public IMochaResult GetRun(MochaDatabase database, string mochaQ)
{
Database = database;
MochaQ = mochaQ;
return(GetRun());
}
/// <summary>
/// Create new MochaQuery.
/// </summary>
/// <param name="database">MochaDatabase object to use querying.</param>
/// <param name="mochaQ">MochaQuery to use.</param>
public MochaQuery(MochaDatabase database, string mochaQ)
: this(database) {
MochaQ = mochaQ;
}
/// <summary>
/// Create new MochaQuery.
/// </summary>
/// <param name="database">MochaDatabase object to use querying.</param>
public MochaQuery(MochaDatabase database)
{
IsDatabaseEmbedded = false;
Database = database;
MochaQ = "BREAKQUERY";
}
/// <summary>
/// Returns command must result.
/// </summary>
/// <param name="tdb">Target database.</param>
/// <param name="command">Command.</param>
/// <param name="table">Table.</param>
/// <param name="row">Row.</param>
/// <param name="from">Use state FROM keyword.</param>
public static bool IsPassTable(MochaDatabase tdb, ref string command, MochaTableResult table, MochaRow row, bool from)
{
command = command.Trim();
if (Mhql_INEQ.IsINEQ(command))
{
return(Mhql_INEQ.Process(tdb, command, table, row, from, false));
}
else if (Mhql_INEQ.IsIN(command))
{
return(Mhql_INEQ.Process(tdb, command, table, row, from, true));
}
else if (MhqlEng_CONDITION.IsCondition(command, out _))
{
return(MhqlEng_CONDITION.Process(command, table, row, from));
}
else if (char.IsNumber(command[0]))
{
return(new Regex(command.Substring(2).Remove(command.Length - 3, 1))
.IsMatch(GetDataFromCommand(command, row).ToString()));
}
else if (command.StartsWith("BETWEEN(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_BETWEEN.Pass(command.Substring(8, command.Length - 9), table, row, from));
}
else if (command.StartsWith("BIGGER(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_BIGGER.Pass(command.Substring(7, command.Length - 8), table, row, from));
}
else if (command.StartsWith("LOWER(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_LOWER.Pass(command.Substring(6, command.Length - 7), table, row, from));
}
else if (command.StartsWith("EQUAL(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_EQUAL.Pass(command.Substring(6, command.Length - 7), table, row, from));
}
else if (command.StartsWith("NOTEQUAL(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_NOTEQUAL.Pass(command.Substring(9, command.Length - 10), table, row, from));
}
else if (command.StartsWith("STARTW(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_STARTW.Pass(command.Substring(7, command.Length - 8), table, row, from));
}
else if (command.StartsWith("ENDW(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_ENDW.Pass(command.Substring(5, command.Length - 6), table, row, from));
}
else if (command.StartsWith("CONTAINS(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_CONTAINS.Pass(command.Substring(9, command.Length - 10), table, row, from));
}
else if (command.StartsWith("NOTCONTAINS(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_NOTCONTAINS.Pass(command.Substring(12, command.Length - 13), table, row, from));
}
else if (command.StartsWith("NOTSTARTW(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_NOTSTARTW.Pass(command.Substring(10, command.Length - 11), table, row, from));
}
else if (command.StartsWith("NOTENDW(", StringComparison.OrdinalIgnoreCase) && command[command.Length - 1] == ')')
{
return(MhqlMustFunc_NOTENDW.Pass(command.Substring(8, command.Length - 9), table, row, from));
}
else
{
throw new InvalidOperationException($"'{command}' is cannot processed!");
}
}
/// <summary>
/// Runs the active MochaQ query. Even if there is an incoming value, it will not return.
/// </summary>
/// <param name="database">MochaDatabase object that provides management of the targeted MochaDB database.</param>
/// <param name="mochaQ">MochaQ to be set as the active MochaQ Query.</param>
public virtual void Run(MochaDatabase database, string mochaQ)
{
Database = database;
Command = mochaQ;
Run();
}
/// <summary>
/// Runs the active MochaQ query. Even if there is an incoming value, it will not return.
/// </summary>
/// <param name="database">MochaDatabase object that provides management of the targeted MochaDB database.</param>
/// <param name="mochaQ">MochaQ to be set as the active MochaQ Query.</param>
public void Run(MochaDatabase database, string mochaQ)
{
Database = database;
MochaQ = mochaQ;
Run();
}
/// <summary>
/// Runs the active MochaQ query. Even if there is an incoming value, it will not return.
/// </summary>
public virtual void Run()
{
Database.OnConnectionCheckRequired(this, new EventArgs());
//Check null.
if (string.IsNullOrEmpty(Command))
{
return;
}
string[] queryPaths = Command.Split(':');
queryPaths[0] = queryPaths[0].ToUpperInvariant();
switch (queryPaths.Length)
{
case 1:
switch (queryPaths[0])
{
case "RESETMOCHA":
Database.Reset();
return;
case "RESETTABLES":
Database.OnChanging(this, new EventArgs());
foreach (XElement element in Database.CDoc.Root.Element("Tables").Elements())
{
element.Elements().Remove();
}
Database.Save();
return;
case "CLEARTABLES":
Database.ClearTables();
return;
case "CLEARALL":
Database.ClearAll();
return;
case "CLEARLOGS":
Database.ClearLogs();
return;
case "RESTORETOFIRSTLOG":
Database.RestoreToFirstLog();
return;
case "RESTORETOLASTLOG":
Database.RestoreToLastLog();
return;
default:
throw new InvalidOperationException("Invalid query. The content of the query could not be processed, wrong!");
}
case 2:
switch (queryPaths[0])
{
case "REMOVETABLE":
Database.RemoveTable(queryPaths[1]);
return;
case "CREATETABLE":
Database.CreateTable(queryPaths[1]);
return;
case "SETPASSWORD":
Database.SetPassword(queryPaths[1]);
return;
case "SETDESCRIPTION":
Database.SetDescription(queryPaths[1]);
return;
case "RESTORETOLOG":
Database.RestoreToLog(queryPaths[1]);
return;
case "CLEARROWS":
Database.ClearRows(queryPaths[1]);
return;
case "RESETTABLE":
if (!Database.ExistsTable(queryPaths[1]))
{
throw new Exception("Table not found in this name!");
}
Database.OnChanging(this, new EventArgs());
Database.CDoc.Root.Element("Tables").Elements(queryPaths[1]).Elements().Remove();
Database.Save();
return;
case "CREATEMOCHA":
MochaDatabase.CreateMochaDB(queryPaths[1], string.Empty, string.Empty);
return;
default:
throw new InvalidOperationException("Invalid query. The content of the query could not be processed, wrong!");
}
case 3:
switch (queryPaths[0])
{
case "REMOVECOLUMN":
Database.RemoveColumn(queryPaths[1], queryPaths[2]);
return;
case "SETTABLEDESCRIPTION":
Database.SetTableDescription(queryPaths[1], queryPaths[2]);
return;
case "REMOVEROW":
Database.RemoveRow(queryPaths[1], int.Parse(queryPaths[2]));
return;
case "RENAMETABLE":
Database.RenameTable(queryPaths[1], queryPaths[2]);
return;
case "CREATECOLUMN":
Database.CreateColumn(queryPaths[1], queryPaths[2]);
return;
case "CREATEMOCHA":
MochaDatabase.CreateMochaDB(Path.Combine(queryPaths[1] + queryPaths[2]), string.Empty, string.Empty);
return;
default:
throw new InvalidOperationException("Invalid query. The content of the query could not be processed, wrong!");
}
case 4:
switch (queryPaths[0])
{
case "RENAMECOLUMN":
Database.RenameColumn(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
case "SETCOLUMNDESCRIPTION":
Database.SetColumnDescription(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
case "SETCOLUMNDATATYPE":
Database.SetColumnDataType(queryPaths[1], queryPaths[2], MochaData.GetDataTypeFromName(queryPaths[3]));
return;
case "ADDDATA":
if (queryPaths[3] != string.Empty)
{
Database.AddData(queryPaths[1], queryPaths[2], queryPaths[3]);
}
else
{
Database.AddData(queryPaths[1], queryPaths[2], null);
}
return;
case "UPDATEFIRSTDATA":
Database.UpdateFirstData(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
case "UPDATELASTDATA":
Database.UpdateLastData(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
default:
throw new InvalidOperationException("Invalid query. The content of the query could not be processed, wrong!");
}
case 5:
switch (queryPaths[0])
{
case "UPDATEDATA":
Database.UpdateData(queryPaths[1], queryPaths[2], int.Parse(queryPaths[3]), queryPaths[4]);
return;
default:
throw new InvalidOperationException("Invalid query. The content of the query could not be processed, wrong!");
}
default:
throw new InvalidOperationException("Invalid query. The content of the query could not be processed, wrong!");
}
}
/// <summary> /// Constructor. /// </summary> /// <param name="db">Target database.</param> public Mhql_DELCOL(MochaDatabase db) =>
/// <summary> /// Initialize a new instance. /// </summary> /// <param name="db">Target database.</param> public Mhql_ADDROW(MochaDatabase db) =>
/// <summary>
/// Create a new Mhql_REMOVE.
/// </summary>
/// <param name="db">Target database.</param>
public Mhql_REMOVE(MochaDatabase db)
{
Command = string.Empty;
Tdb = db;
}
/// <summary>
/// Create a new Mhql_GROUPBY.
/// </summary>
/// <param name="db">Target database.</param>
public Mhql_GROUPBY(MochaDatabase db)
{
Tdb = db;
}
/// <summary>
/// Create a new Mhql_ORDERBY.
/// </summary>
/// <param name="db">Target database.</param>
public Mhql_ORDERBY(MochaDatabase db)
{
Command = string.Empty;
Tdb = db;
}
/// <summary>
/// Runs the active MochaQ query. Even if there is an incoming value, it will not return.
/// </summary>
public void Run()
{
if (!MochaQ.IsRunQuery())
{
throw new MochaException(@"This MochaQ command is not ""Run"" type command.");
}
Database.OnConnectionCheckRequired(this, new EventArgs());
if (Database.Provider.Readonly)
{
throw new MochaException("This connection is can read only, cannot task of write!");
}
//Check null.
if (string.IsNullOrEmpty(MochaQ))
{
throw new MochaException("This MochaQ query is empty, invalid!");
}
//Check BREAKQUERY.
if (MochaQ.Command.Contains("BREAKQUERY"))
{
return;
}
string[] queryPaths = MochaQ.Command.Split(':');
queryPaths[0] = queryPaths[0].ToUpperInvariant();
//File system.
if (queryPaths[0].StartsWith("FILESYSTEM_"))
{
if (queryPaths.Length == 1)
{
if (queryPaths[0] == "FILESYSTEM_CLEARDISKS")
{
Database.FileSystem.ClearDisks();
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
else if (queryPaths.Length == 2)
{
if (queryPaths[0] == "FILESYSTEM_REMOVEDISK")
{
Database.FileSystem.RemoveDisk(queryPaths[1]);
return;
}
else if (queryPaths[0] == "FILESYSTEM_REMOVEDIRECTORY")
{
Database.FileSystem.RemoveDirectory(queryPaths[1]);
return;
}
else if (queryPaths[0] == "FILESYSTEM_REMOVEFILE")
{
Database.FileSystem.RemoveFile(queryPaths[1]);
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
else if (queryPaths.Length == 3)
{
if (queryPaths[0] == "FILESYSTEM_CREATEDISK")
{
Database.FileSystem.CreateDisk(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "FILESYSTEM_CREATEDIRECTORY")
{
Database.FileSystem.CreateDirectory(queryPaths[1], queryPaths[2]);
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
if (queryPaths.Length == 1)
{
if (queryPaths[0] == "RESETMOCHA")
{
Database.Reset();
return;
}
else if (queryPaths[0] == "RESETTABLES")
{
Database.OnChanging(this, new EventArgs());
IEnumerable <XElement> tableRange = Database.Doc.Root.Element("Tables").Elements();
for (int index = 0; index < tableRange.Count(); index++)
{
tableRange.ElementAt(index).Elements().Remove();
}
Database.Save();
return;
}
else if (queryPaths[0] == "CLEARSECTORS")
{
Database.ClearSectors();
return;
}
else if (queryPaths[0] == "CLEARSTACKS")
{
Database.ClearStacks();
return;
}
else if (queryPaths[0] == "CLEARTABLES")
{
Database.ClearTables();
return;
}
else if (queryPaths[0] == "CLEARALL")
{
Database.ClearAll();
return;
}
else if (queryPaths[0] == "CLEARLOGS")
{
Database.ClearLogs();
return;
}
else if (queryPaths[0] == "RESTORETOFIRSTLOG")
{
Database.RestoreToFirstLog();
return;
}
else if (queryPaths[0] == "RESTORETOLASTLOG")
{
Database.RestoreToLastLog();
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
else if (queryPaths.Length == 2)
{
if (queryPaths[0] == "REMOVETABLE")
{
Database.RemoveTable(queryPaths[1]);
return;
}
else if (queryPaths[0] == "CREATETABLE")
{
Database.CreateTable(queryPaths[1]);
return;
}
else if (queryPaths[0] == "CREATESTACK")
{
Database.AddStack(new MochaStack(queryPaths[1]));
return;
}
else if (queryPaths[0] == "REMOVESECTOR")
{
Database.RemoveSector(queryPaths[1]);
return;
}
else if (queryPaths[0] == "REMOVESTACK")
{
Database.RemoveStack(queryPaths[1]);
return;
}
else if (queryPaths[0] == "SETPASSWORD")
{
Database.SetPassword(queryPaths[1]);
return;
}
else if (queryPaths[0] == "SETDESCRIPTION")
{
Database.SetDescription(queryPaths[1]);
return;
}
else if (queryPaths[0] == "RESTORETOLOG")
{
Database.RestoreToLog(queryPaths[1]);
return;
}
else if (queryPaths[0] == "CLEARROWS")
{
Database.ClearRows(queryPaths[1]);
return;
}
else if (queryPaths[0] == "RESETTABLE")
{
if (!Database.ExistsTable(queryPaths[1]))
{
throw new MochaException("Table not found in this name!");
}
Database.OnChanging(this, new EventArgs());
Database.Doc.Root.Element("Tables").Elements(queryPaths[1]).Elements().Remove();
Database.Save();
return;
}
else if (queryPaths[0] == "CREATEMOCHA")
{
MochaDatabase.CreateMochaDB(Path.Combine(queryPaths[1]) + ".bjay", string.Empty, string.Empty);
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
else if (queryPaths.Length == 3)
{
if (queryPaths[0] == "REMOVECOLUMN")
{
Database.RemoveColumn(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "REMOVETABLEATTRIBUTE")
{
Database.RemoveTableAttribute(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "REMOVESTACKATTRIBUTE")
{
Database.RemoveStackAttribute(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "REMOVESECTORATTRIBUTE")
{
Database.RemoveSectorAttribute(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "SETSECTORDATA")
{
Database.SetSectorData(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "SETSECTORDESCRIPTION")
{
Database.SetSectorDescription(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "SETSTACKDESCRIPTION")
{
Database.SetStackDescription(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "SETTABLEDESCRIPTION")
{
Database.SetTableDescription(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "REMOVEROW")
{
Database.RemoveRow(queryPaths[1], int.Parse(queryPaths[2]));
return;
}
else if (queryPaths[0] == "RENAMETABLE")
{
Database.RenameTable(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "REMOVESTACKITEM")
{
Database.RemoveStackItem(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "RENAMESECTOR")
{
Database.RenameSector(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "RENAMESTACK")
{
Database.RenameStack(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "CREATECOLUMN")
{
Database.CreateColumn(queryPaths[1], queryPaths[2]);
return;
}
else if (queryPaths[0] == "CREATEMOCHA")
{
MochaDatabase.CreateMochaDB(Path.Combine(queryPaths[1] + queryPaths[2]) + ".bjay", string.Empty, string.Empty);
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
else if (queryPaths.Length == 4)
{
if (queryPaths[0] == "RENAMECOLUMN")
{
Database.RenameColumn(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "REMOVECOLUMNATTRIBUTE")
{
Database.RemoveColumnAttribute(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "REMOVESTACKITEMATTRIBUTE")
{
Database.RemoveStackItemAttribute(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "SETCOLUMNDESCRIPTION")
{
Database.SetColumnDescription(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "SETCOLUMNDATATYPE")
{
Database.SetColumnDataType(queryPaths[1], queryPaths[2], MochaData.GetDataTypeFromName(queryPaths[3]));
return;
}
else if (queryPaths[0] == "ADDDATA")
{
Console.WriteLine((queryPaths[3] != "") + "||'" + queryPaths[3] + "'");
if (queryPaths[3] != "")
{
Database.AddData(queryPaths[1], queryPaths[2],
MochaData.GetDataFromString(
Database.GetColumnDataType(queryPaths[1], queryPaths[2])
, queryPaths[3]));
}
else
{
Database.AddData(queryPaths[1], queryPaths[2], null);
}
return;
}
else if (queryPaths[0] == "CREATESTACKITEM")
{
Database.AddStackItem(queryPaths[1], queryPaths[3], new MochaStackItem(queryPaths[2]));
return;
}
else if (queryPaths[0] == "RENAMESTACKITEM")
{
Database.RenameStackItem(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "SETSTACKITEMVALUE")
{
Database.SetStackItemValue(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "SETSTACKITEMDESCRIPTION")
{
Database.SetStackItemDescription(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "UPDATEFIRSTDATA")
{
Database.UpdateFirstData(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "UPDATELASTDATA")
{
Database.UpdateLastData(queryPaths[1], queryPaths[2], queryPaths[3]);
return;
}
else if (queryPaths[0] == "ADDSECTOR")
{
MochaSector Sector = new MochaSector(queryPaths[1], queryPaths[2], queryPaths[3]);
Database.AddSector(Sector);
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
else if (queryPaths.Length == 5)
{
if (queryPaths[0] == "UPDATEDATA")
{
Database.UpdateData(queryPaths[1], queryPaths[2], int.Parse(queryPaths[3]), queryPaths[4]);
return;
}
else
{
throw new MochaException("Invalid query. The content of the query could not be processed, wrong!");
}
}
}
/// <summary>
/// Create new MochaQuery.
/// </summary>
/// <param name="database">MochaDatabase object to use querying.</param>
/// <param name="embedded">Is embedded query in database.</param>
internal MochaQuery(MochaDatabase database, bool embedded)
{
this.database = database;
MochaQ = "BREAKQUERY";
IsDatabaseEmbedded = embedded;
}
/// <summary>
/// Create a new MochaDbCommand.
/// </summary>
/// <param name="command">MQL Command.</param>
/// <param name="db">Target MochaDatabase.</param>
public MochaDbCommand(string command, MochaDatabase db) :
this(db) {
Command = command;
}
/// <summary> /// Constructor. /// </summary> /// <param name="db">Target database.</param> public Mhql_SUBROW(MochaDatabase db) =>
/// <summary>
/// Create a new Mhql_MUST.
/// </summary>
/// <param name="db">Target database.</param>
public Mhql_MUST(MochaDatabase db)
{
Command = string.Empty;
Tdb = db;
}
/// <summary>
/// If the value is returned, it returns the function and performs the function; if not, it just performs the function.
/// </summary>
/// <param name="database">MochaDatabase object that provides management of the targeted MochaDB database.</param>
/// <param name="mochaQ">MochaQ to be set as the active MochaQ Query.</param>
public IMochaResult Dynamic(MochaDatabase database, string mochaQ)
{
Database = database;
MochaQ = mochaQ;
return(Dynamic());
}
