/// <summary>
/// Process mhql query part.
/// </summary>
/// <param name="value">Query.</param>
/// <param name="table">Table.</param>
/// <param name="from">Use state FROM keyword.</param>
public static void ProcessPart(ref string value, MochaTableResult table, bool from)
{
if (!from)
{
int _dex = value.IndexOf('(');
if (_dex == -1)
{
return;
}
string _val = value.Substring(0, _dex).Trim();
value = _val + value.Substring(_dex);
return;
}
int dex = value.IndexOf('(');
if (dex == -1)
{
return;
}
string val = value.Substring(0, dex).Trim();
IEnumerable <MochaColumn> result = table.Columns.Where(x => x.Name == val);
if (!result.Any())
{
return;
}
value = Array.IndexOf(table.Columns, result.First()) + value.Substring(dex);
}
/// <summary>
/// Returns table as XmlReader.
/// </summary>
/// <param name="table">Table to convert.</param>
public static XmlReader ToXmlTable(MochaTableResult table)
{
if (table.Columns.Length == 0)
{
var val =
$@"<Root>
<Table></Table>
</Root>";
return(XmlReader.Create(new StringReader(val)));
}
var doc = XDocument.Parse(
@"<Root>
</Root>");
for (int dex = 0; dex < table.Rows.Length; dex++)
{
XElement row = new XElement("Table");
for (int columnIndex = 0; columnIndex < table.Columns.Length; columnIndex++)
{
var column = table.Columns[columnIndex];
XElement value = new XElement(column.Name);
value.Value = column.Datas[dex].Data.ToString();
row.Add(value);
}
doc.Root.Add(row);
}
return(doc.CreateReader());
}
/// <summary>
/// Process condition and returns condition result.
/// </summary>
/// <param name="command">Condition.</param>
/// <param name="table">Table.</param>
/// <param name="row">Row.</param>
/// <param name="from">Use state FROM keyword.</param>
public static bool Process(string command, MochaTableResult table, MochaRow row, bool from)
{
ConditionType type;
if (!IsCondition(command, out type))
{
return(false);
}
string[] parts = GetConditionParts(command, MhqlEng_CONDITION_LEXER.Operators[type.ToString()]);
Expressional value0 = GetValue(parts[0], table, row, from);
Expressional value1 = GetValue(parts[1], table, row, from);
if (value0.Type != value1.Type)
{
throw new InvalidCastException("Value types is are not compatible!");
}
switch (type)
{
case ConditionType.EQUAL: return(value0.Equal(value1));
case ConditionType.NOTEQUAL: return(value0.NotEqual(value1));
case ConditionType.BIGGER: return(value0.Bigger(value1));
case ConditionType.LOWER: return(value0.Lower(value1));
case ConditionType.BIGGEREQ: return(value0.BiggerEqual(value1));
case ConditionType.LOWEREQ: return(value0.LowerEqual(value1));
default: return(false);
}
}
/// <summary>
/// Pass command?
/// </summary>
/// <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 Pass(string command, MochaTableResult table, MochaRow row, bool from)
{
string[] parts = Mhql_LEXER.SplitFunctionParameters(command);
if (parts.Length != 3)
{
throw new ArgumentOutOfRangeException("The BETWEEN function can only take 3 parameters!");
}
int dex = Mhql_GRAMMAR.GetIndexOfColumn(parts[0], table.Columns, from);
decimal
range1,
range2,
value;
if (!decimal.TryParse(parts[1].Trim(), out range1) ||
!decimal.TryParse(parts[2].Trim(), out range2) ||
!decimal.TryParse(row.Datas[dex].Data.ToString(), out value))
{
throw new ArithmeticException("The parameter of the BETWEEN command was not a number!");
}
return
(range1 <= range2 ?
range1 <= value && value <= range2 :
range2 <= value && value <= range1);
}
/// <summary>
/// Pass command?
/// </summary>
/// <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 Pass(string command, MochaTableResult table, MochaRow row, bool from)
{
string[] parts = Mhql_LEXER.SplitFunctionParameters(command);
int dex = Mhql_GRAMMAR.GetIndexOfColumn(parts[0], table.Columns, from);
for (int index = 1; index < parts.Length; ++index)
{
if (row.Datas[dex].Data.ToString().StartsWith(parts[index]))
{
return(true);
}
}
return(false);
}
/// <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());
}
}
/// <summary>
/// Must by tables.
/// </summary>
/// <param name="command">Must command.</param>
/// <param name="table">Table.</param>
/// <param name="from">Use state FROM keyword.</param>
public void MustTable(string command, ref MochaTableResult table, bool from)
{
command = command.Trim();
var parts = Mhql_AND.GetParts(command);
for (int index = 0; index < parts.Length; index++)
{
var partcmd = parts[index];
MhqlEng_MUST.ProcessPart(ref partcmd, table, from);
table.Rows = (
from value in table.Rows
where MhqlEng_MUST.IsPassTable(ref partcmd, value)
select value
).ToArray();
}
table.SetDatasByRows();
}
/// <summary>
/// Orderby by command.
/// </summary>
/// <param name="command">Orderby command.</param>
/// <param name="table">Table to ordering.</param>
/// <param name="from">Use state FROM keyword.</param>
public void OrderBy(string command, ref MochaTableResult table, bool from)
{
MHQLOrderType DecomposeOrder(string cmd, ref MochaTableResult tbl, out int coldex)
{
string[] orderparts = cmd.Trim().Split(' ');
if (orderparts.Length > 2)
{
throw new ArgumentOutOfRangeException("A single ORDERBY parameter can consist of up to 2 parts!");
}
coldex = Mhql_GRAMMAR.GetIndexOfColumn(orderparts[0].Trim(), tbl.Columns, from);
if (orderparts.Length == 1)
{
return(0);
}
string order = orderparts[orderparts.Length - 1].Trim();
return(order == string.Empty ||
order.StartsWith("ASC", StringComparison.OrdinalIgnoreCase) ?
MHQLOrderType.ASC :
order.StartsWith("DESC", StringComparison.OrdinalIgnoreCase) ?
MHQLOrderType.DESC :
throw new Exception("ORDERBY could not understand this '" + order + "' sort type!"));
}
command = command.Trim();
string[] parts = Mhql_LEXER.SplitParameters(command);
int columndex;
IOrderedEnumerable <MochaRow> rows =
DecomposeOrder(parts[0], ref table, out columndex) == 0 ?
table.Rows.OrderBy(x => x.Datas[columndex].ToString(), new ORDERBYComparer()) :
table.Rows.OrderByDescending(x => x.Datas[columndex].ToString(), new ORDERBYComparer());
for (int index = 1; index < parts.Length; ++index)
{
int coldex;
rows =
DecomposeOrder(parts[index], ref table, out coldex) == 0 ?
rows.ThenBy(x => x.Datas[coldex].ToString(), new ORDERBYComparer()) :
rows.ThenByDescending(x => x.Datas[coldex].ToString(), new ORDERBYComparer());
}
table.Rows = rows.ToArray();
table.SetDatasByRows();
}
/// <summary>
/// Process mhql query part.
/// </summary>
/// <param name="value">Query.</param>
/// <param name="table">Table.</param>
/// <param name="from">Use state FROM keyword.</param>
public static void ProcessPart(ref string value, MochaTableResult table, bool from)
{
if (!from)
{
return;
}
var dex = value.IndexOf('(');
var val = value.Substring(0, dex);
var result = table.Columns.Where(x => x.Name == val);
if (result.Count() == 0)
{
return;
}
value = table.Columns.IndexOf(result.First()) + value.Substring(dex);
}
/// <summary>
/// Show table result.
/// </summary>
/// <param name="table">Table.</param>
public void ShowTable(MochaTableResult table)
{
var tableGrid = new sgrid();
tableGrid.Dock = DockStyle.Fill;
tableGrid.BackgroundColor = BackColor;
tableGrid.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
for (int columnIndex = 0; columnIndex < table.Columns.Length; columnIndex++)
{
tableGrid.Columns.Add(string.Empty, table.Columns[columnIndex].MHQLAsText);
}
for (int rowIndex = 0; rowIndex < table.Rows.Length; rowIndex++)
{
tableGrid.Rows.Add(table.Rows[rowIndex].Datas.ToArray());
}
control = tableGrid;
Controls.Add(tableGrid);
}
/// <summary>
/// COrderby by command.
/// </summary>
/// <param name="command">COrderby command.</param>
/// <param name="table">Table to ordering.</param>
/// <param name="from">Use state FROM keyword.</param>
public void COrderBy(string command, ref MochaTableResult table)
{
if (Mhql_LEXER.SplitParameters(command).Length > 1)
{
throw new ArgumentOutOfRangeException("CODERBY keyword are can take only one parameter!");
}
command = command.Trim();
string[] parts = command.Split(new[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 1)
{
throw new ArgumentException("CORDERBY order type is not defined!");
}
IOrderedEnumerable <MochaColumn> columns =
parts[1].Equals("ASC", StringComparison.OrdinalIgnoreCase) ?
table.Columns.OrderBy(x => x.Name, new ORDERBYComparer()) :
parts[1].Equals("DESC", StringComparison.OrdinalIgnoreCase) ?
table.Columns.OrderByDescending(x => x.Name, new ORDERBYComparer()) :
throw new Exception("CORDERBY could not understand this sort type!");
table.Columns = columns.ToArray();
table.SetRowsByDatas();
}
/// <summary>
/// Must by tables.
/// </summary>
/// <param name="command">Must command.</param>
/// <param name="table">Table.</param>
/// <param name="from">Use state FROM keyword.</param>
public void MustTable(string command, ref MochaTableResult table, bool from)
{
command = command.Trim();
List <string> parts = Mhql_AND.GetParts(command);
for (int index = 0; index < parts.Count; ++index)
{
string partcmd = parts[index];
MhqlEng_MUST.ProcessPart(ref partcmd, table, from);
List <MochaRow> rows = new List <MochaRow>();
for (int dex = 0; dex < table.Rows.Length; ++dex)
{
MochaRow row = table.Rows[dex];
if (MhqlEng_MUST.IsPassTable(Tdb, ref partcmd, table, row, @from))
{
rows.Add(row);
}
}
table.Rows = rows.ToArray();
}
table.SetDatasByRows();
}
/// <summary>
/// Groupby by command.
/// </summary>
/// <param name="command">Orderby command.</param>
/// <param name="table">Table to ordering.</param>
/// <param name="final">Command of removed use commands.</param>
public void GroupBy(string command, ref MochaTableResult table)
{
command = command.TrimStart().TrimEnd();
int dex =
command.StartsWith("ASC", StringComparison.OrdinalIgnoreCase) ?
3 :
command.StartsWith("DESC", StringComparison.OrdinalIgnoreCase) ?
4 : 0;
int columndex;
if (!int.TryParse(command.Substring(dex), out columndex))
{
throw new MochaException("Item index is cannot processed!");
}
var result =
from value in table.Columns[columndex].Datas
group value by value.Data into grouped
select new { Data = grouped.Key, Count = grouped.Count() };
table.Columns = new[] { new MochaColumn("Datas"), new MochaColumn("Count") };
table.Rows = new MochaRow[result.Count()];
for (int index = 0; index < table.Rows.Length; index++)
{
var item = result.ElementAt(index);
table.Rows[index] = new MochaRow(
new MochaData {
dataType = MochaDataType.String,
data = item.Data
},
new MochaData {
dataType = MochaDataType.Int32,
data = item.Count
});
}
table.SetDatasByRows();
}
/// <summary>
/// Orderby by command.
/// </summary>
/// <param name="command">Orderby command.</param>
/// <param name="table">Table to ordering.</param>
/// <param name="final">Command of removed use commands.</param>
public void OrderBy(string command, ref MochaTableResult table)
{
command = command.TrimStart().TrimEnd();
int dex =
command.StartsWith("ASC", StringComparison.OrdinalIgnoreCase) ?
3 :
command.StartsWith("DESC", StringComparison.OrdinalIgnoreCase) ?
4 : 0;
int columndex;
if (!int.TryParse(command.Substring(dex), out columndex))
{
throw new MochaException("Item index is cannot processed!");
}
table.Rows.array = (
dex == 0 || dex == 3 ?
table.Rows.OrderBy(x => x.Datas[columndex].ToString()) :
table.Rows.OrderByDescending(x => x.Datas[columndex].ToString())).ToArray();
table.SetDatasByRows();
}
/// <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>
/// Returns table by use command.
/// </summary>
/// <param name="usecommand">Use command.</param>
public MochaTableResult GetTable(string usecommand, bool from)
{
MochaColumn GetColumn(string cmd, IList <MochaColumn> cols)
{
string decomposeBrackets(string value)
{
int dex;
if ((dex = value.IndexOf('(')) != -1)
{
return(value.Substring(dex + 1, value.Length - dex - 2));
}
return(value);
}
string name = Mhql_AS.GetAS(ref cmd);
if (Mhql_GRAMMAR.UseFunctions.MatchKey(cmd))
{
MochaColumn column = new MochaColumn();
column.MHQLAsText = name;
column.Tag =
Mhql_GRAMMAR.UseFunctions.GetValueByMatchKey(cmd);
if (column.Tag != "COUNT")
{
column.Description =
Mhql_GRAMMAR.GetIndexOfColumn(decomposeBrackets(cmd), cols, from).ToString();
}
return(column);
}
else
{
string colname = cmd.StartsWith("$") ? cmd.Substring(1).Trim() : cmd;
IEnumerable <MochaColumn> result = cols.Where(x => x.Name == colname);
if (!result.Any())
{
throw new Exception($"Could not find a column with the name '{cmd}'!");
}
MochaColumn column = result.First();
column.Tag = colname != cmd ? "$" : null;
column.MHQLAsText = name;
return(column);
}
}
List <MochaColumn> columns = new List <MochaColumn>();
MochaTableResult resulttable = new MochaTableResult();
if (from)
{
int dex = Mhql_FROM.GetIndex(ref usecommand);
string tablename = usecommand.Substring(dex + 5).Trim();
List <string> parts = Mhql_LEXER.SplitUseParameters(usecommand.Substring(0, dex));
List <MochaColumn> _columns = Tdb.GetColumns(tablename);
if (parts.Count == 1 && parts[0].Trim() == "*")
{
columns.AddRange(_columns);
}
else
{
if (parts[0].TrimStart().StartsWith("$") &&
parts[0].TrimStart().Substring(1).TrimStart().StartsWith($"{Mhql_LEXER.LBRACE}"))
{
throw new InvalidOperationException("Cannot be used with subquery FROM keyword!");
}
for (int index = 0; index < parts.Count; ++index)
{
columns.Add(GetColumn(parts[index].Trim(), _columns));
}
}
}
else
{
List <string> parts = Mhql_LEXER.SplitUseParameters(usecommand);
for (int index = 0; index < parts.Count; ++index)
{
string callcmd = parts[index].Trim();
if (callcmd == "*")
{
List <MochaTable> tables = Tdb.GetTables();
for (int tindex = 0; tindex < tables.Count; ++tindex)
{
columns.AddRange(tables[tindex].Columns);
}
continue;
}
int obrace = callcmd.IndexOf(Mhql_LEXER.LBRACE);
if (obrace != -1)
{
IList <MochaColumn> _cols = (new MochaDbCommand(Tdb).ExecuteScalar(Mhql_LEXER.RangeSubqueryBrace(
callcmd.Substring(obrace).Trim()))).Columns;
string mode =
callcmd.Substring(0, obrace).TrimStart().StartsWith("$") ?
"$" : string.Empty;
for (int cindex = 0; cindex < _cols.Count; ++cindex)
{
columns.Add(GetColumn($"{mode}{_cols[cindex].Name}", _cols));
}
continue;
}
if (callcmd.StartsWith("$"))
{
callcmd = callcmd.Substring(1).Trim();
List <MochaColumn> _cols = Tdb.GetColumns(callcmd);
for (int cindex = 0; cindex < _cols.Count; ++cindex)
{
columns.Add(GetColumn($"${_cols[cindex].Name}", _cols));
}
continue;
}
string[] callparts = Mhql_LEXER.SplitSubCalls(callcmd);
if (callparts.Length > 2)
{
throw new InvalidOperationException($"'{callcmd}' command is cannot processed!");
}
for (byte partindex = 0; partindex < callparts.Length; ++partindex)
{
callparts[partindex] = callparts[partindex].Trim();
}
List <MochaColumn> _columns = Tdb.GetColumns(callparts[0]);
if (callparts.Length == 1)
{
columns.AddRange(_columns);
}
else
{
columns.Add(GetColumn(callparts[1], _columns));
}
}
}
resulttable.Columns = columns.ToArray();
resulttable.SetRowsByDatas();
return(resulttable);
}
/// <summary>
/// Returns table by use command.
/// </summary>
/// <param name="usecommand">Use command.</param>
public MochaTableResult GetTable(string usecommand, bool from)
{
var columns = new List <MochaColumn>();
var resulttable = new MochaTableResult();
if (from)
{
var dex = usecommand.IndexOf("FROM", StringComparison.OrdinalIgnoreCase);
var tablename = usecommand.Substring(dex + 4).TrimStart().TrimEnd();
var parts = usecommand.Substring(0, dex).Split(',');
var table = Tdb.GetTable(tablename);
if (parts.Length == 1 && parts[0].Trim() == "*")
{
columns.AddRange(table.Columns);
}
else
{
for (var index = 0; index < parts.Length; index++)
{
var callcmd = parts[index].Trim();
var name = Mhql_AS.GetAS(ref callcmd);
var column = table.Columns[callcmd];
column.Name = name;
columns.Add(column);
}
}
}
else
{
var parts = usecommand.Split(',');
for (var index = 0; index < parts.Length; index++)
{
var callcmd = parts[index].Trim();
if (callcmd == "*")
{
var tables = Tdb.GetTables();
for (int tindex = 0; tindex < tables.Count; tindex++)
{
columns.AddRange(tables[tindex].Columns);
}
continue;
}
var callparts = callcmd.Split('.');
if (callparts.Length > 2)
{
throw new MochaException($"'{callcmd}' command is cannot processed!");
}
for (byte partindex = 0; partindex < callparts.Length; partindex++)
{
callparts[partindex] = callparts[partindex].Trim();
}
var table = Tdb.GetTable(callparts[0]);
if (callparts.Length == 1)
{
columns.AddRange(table.Columns);
}
else
{
var callp1 = callparts[1];
var name = Mhql_AS.GetAS(ref callp1);
var column = table.Columns[callp1];
column.Name = name;
columns.Add(column);
}
}
}
resulttable.Columns = columns.ToArray();
resulttable.SetRowsByDatas();
return(resulttable);
}
/// <summary>
/// Returns sector table by use command.
/// </summary>
/// <param name="usecommand">Use command.</param>
public MochaTableResult GetSector(string usecommand, bool from)
{
if (from)
{
throw new MochaException("FROM keyword is cannot used with @SECTORS marked commands!");
}
var resulttable = new MochaTableResult {
Columns = new[] {
new MochaColumn("Name"),
new MochaColumn("Description"),
new MochaColumn("Data")
}
};
var rows = new List <MochaRow>();
var parts = usecommand.Split(',');
for (var index = 0; index < parts.Length; index++)
{
var callcmd = parts[index].TrimStart().TrimEnd();
if (callcmd == "*")
{
var sectors = Tdb.GetSectors();
for (int sindex = 0; sindex < sectors.Count; sindex++)
{
var currentsector = sectors.ElementAt(sindex);
rows.Add(new MochaRow(
new MochaData {
data = currentsector.Name,
dataType = MochaDataType.String
},
new MochaData {
data = currentsector.Description,
dataType = MochaDataType.String
},
new MochaData {
data = currentsector.Data,
dataType = MochaDataType.String
}
));
}
}
else
{
var sector = Tdb.GetSector(callcmd);
rows.Add(new MochaRow(
new MochaData {
data = sector.Name,
dataType = MochaDataType.String
},
new MochaData {
data = sector.Description,
dataType = MochaDataType.String
},
new MochaData {
data = sector.Data,
dataType = MochaDataType.String
}
));
}
}
resulttable.Rows = rows.ToArray();
return(resulttable);
}
/// <summary>
/// Returns value.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="table">Table.</param>
/// <param name="row">Row.</param>
/// <param name="from">Use state FROM keyword.</param>
public static Expressional GetValue(string value, MochaTableResult table, MochaRow row, bool from)
{
if (value.StartsWith("'"))
{
MhqlEngVal_CHAR.Process(ref value);
return(new Expressional {
Type = ExpressionType.Char,
Value = value
});
}
else if (value.StartsWith("\""))
{
MhqlEngVal_STRING.Process(ref value);
return(new Expressional {
Type = ExpressionType.String,
Value = value
});
}
else if (value.StartsWith("#"))
{
decimal val;
if (!decimal.TryParse(value.Substring(1).Replace('.', ','), out val))
{
throw new ArithmeticException("Value is not arithmetic value!");
}
return(new Expressional {
Type = ExpressionType.Arithmetic,
Value = val
});
}
else if (value == "TRUE")
{
return new Expressional {
Type = ExpressionType.Boolean,
Value = true
}
}
;
else if (value == "FALSE")
{
return new Expressional {
Type = ExpressionType.Boolean,
Value = false
}
}
;
if (from)
{
IEnumerable <MochaColumn> result = table.Columns.Where(x => x.Name == value);
if (!result.Any())
{
goto index;
}
MochaData data = row.Datas[Array.IndexOf(table.Columns, result.First())];
return(new Expressional {
Type =
data.dataType == MochaDataType.Unique ||
data.dataType == MochaDataType.String ||
data.dataType == MochaDataType.DateTime ?
ExpressionType.String :
data.dataType == MochaDataType.Char ?
ExpressionType.Char :
data.dataType == MochaDataType.Boolean ?
ExpressionType.Boolean :
ExpressionType.Arithmetic,
Value = data.data
});
}
index:
if (!char.IsNumber(value[0]))
{
throw new ArgumentException("Column is not defined!");
}
int dex = int.Parse(value);
if (dex < 0)
{
throw new ArgumentOutOfRangeException("Index is cannot lower than zero!");
}
else if (dex > row.Datas.Count - 1)
{
throw new ArgumentOutOfRangeException("The specified index is more than the number of columns!");
}
MochaData _data = row.Datas[dex];
return(new Expressional {
Type =
_data.dataType == MochaDataType.Unique ||
_data.dataType == MochaDataType.String ||
_data.dataType == MochaDataType.DateTime ?
ExpressionType.String :
_data.dataType == MochaDataType.Char ?
ExpressionType.Char :
_data.dataType == MochaDataType.Boolean ?
ExpressionType.Boolean :
ExpressionType.Arithmetic,
Value = _data.data
});
}
#endregion Members
}
