public static string CreateSql <T>(this T entity)
{
var et = typeof(T);
var cols = new List <string>();
var infos = et.GetProperties();
var tableAttr = et.GetCustomAttributes(typeof(TableNameAttribute), true);
var tableName = tableAttr.Any() ? (tableAttr[0] as TableNameAttribute).Name : et.Name;
var descriptions = new StringBuilder();
var sql = "CREATE TABLE [{0}] ({1});";
var pk = "CONSTRAINT [PK_{0}] PRIMARY KEY CLUSTERED([{1}] ASC)";
var isHasPrimary = false;
foreach (var item in infos)
{
var identity = string.Empty;
var isKey = item.Name == "Id" || item.GetCustomAttributes(typeof(KeyAttribute), true).Any();
if (isKey)
{
identity = item.PropertyType == typeof(string) ? string.Empty : "IDENTITY(1,1)";
pk = string.Format(pk, tableName, item.Name);
isHasPrimary = true;
}
var nullable = TypeOperator.IsNullable(item.PropertyType) ? "NULL" : "NOT NULL";
if (isKey)
{
nullable = "NOT NULL";
}
var timeDefault = item.PropertyType == typeof(DateTime) ? "DEFAULT (GETDATE())" : string.Empty;
var sqlType = item.PropertyType.ToSqlType();
sqlType = sqlType == "nvarchar" ? "[nvarchar](max)" : string.Format("[{0}]", sqlType);
if (sqlType == "[nvarchar](max)" && isKey)
{
sqlType = "[varchar](500)";
}
cols.Add(string.Format("[{0}] {1} {2} {3} {4}", item.Name, sqlType, identity, nullable, timeDefault));
var colAttr = item.GetCustomAttributes(typeof(DescriptionAttribute), true);
if (colAttr.Any())
{
var attrName = (colAttr[0] as DescriptionAttribute).Name;
descriptions.AppendLine(string.Format(@"EXEC sp_addextendedproperty @name=N'MS_Description',@value=N'{0}',@level0type=N'Schema',@level0name=N'dbo',@level1type=N'Table',@level1name=N'{1}',@level2type=N'Column',@level2name=N'{2}';", attrName, tableName, item.Name));
}
}
if (isHasPrimary)
{
cols.Add(pk);
}
var result = string.Format(sql + "{2}", tableName, string.Join(",", cols), descriptions);
return(result);
}
private QuantityTypeService()
{
XElement _typeInformations = getTypeInformations();
//register the type and quantity protype
foreach (XElement _typeContent in _typeInformations.Elements("QuantityType"))
{
(TypeId, IQuantityType)result = _getTypeFromXml(_typeContent);
_typeSet.Add(result.Item1, result.Item2);
}
//register the expression of type
foreach (XElement _typeContent in _typeInformations.Elements("QuantityType"))
{
XElement _expContent = _typeContent.Element("expression");
if (_expContent.HasElements)
{
//get result type
TypeId resultId = _getTypeId(_typeContent);
//get type operand .
string _leftref = _expContent.Element("left")
.Attribute("ref").Value;
string _rightref = _expContent.Element("right")
.Attribute("ref").Value;
XElement _leftContent =
_typeInformations.Elements("QuantityType")
.Where((x) => x.Attribute("code").Value == _leftref)
.First();
XElement _rightContent =
_typeInformations.Elements("QuantityType")
.Where((x) => x.Attribute("code").Value == _rightref)
.First();
TypeId leftId = _getTypeId(_leftContent);
TypeId rightId = _getTypeId(_rightContent);
string _op = _expContent.Element("operator").Value;
TypeOperator op = TypeOperator.Divide;
if (_op == "Multiply")
{
op = TypeOperator.Multiply;
}
TypeExpression typeExp =
new TypeExpression(_typeSet[leftId], _typeSet[rightId], op);
LogType(typeExp, _typeSet[resultId]);
}
}
}
/// <summary>Gets a binary operation.</summary>
/// <param name="op">The operation's operator type.</param>
/// <param name="right">The right object's type.</param>
/// <returns>A TypeOperation if the operation is found. Null if it is not found.</returns>
public virtual ITypeOperation GetOperation(TypeOperator op, CodeType right)
{
CodeType current = _type;
while (current != null)
{
if (current.Operations != null)
{
foreach (ITypeOperation operation in current.Operations._typeOperations)
{
if (operation.Operator == op && right != null && right.Implements(operation.Right))
{
return(operation);
}
}
}
current = current.Extends;
}
return(null);
}
private static ExpTreeNode GetAsExpressionTree(this ParseTreeNode parsedNode, ExpTreeNode parentExpNode)
{
//The current node is a variable / value token. Create a value node and return it back
if (!parsedNode.ChildNodes.Any())
{
switch (parsedNode.Term.Name)
{
case "variable":
{
var varName = parsedNode.FindTokenAndGetValue <string>();
return(new VariableValue(varName, parentExpNode));
}
case "boolean":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <bool>(), parentExpNode));
case "integer":
case "decimal":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <double>(), parentExpNode));
case "SingleQuoteString":
case "DoubleQuoteString":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <string>(), parentExpNode));
default:
throw parsedNode.GetException($"Invalid token type '{parsedNode.Term.Name}' in expression");
}
}
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 1)
{
return(GetAsExpressionTree(parsedNode.ChildNodes[0], parentExpNode));
}
//Ignore parenthesis, the middle non-terminal is what we want
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 3 && parsedNode.ChildNodes[0]?.Token?.Text == "(")
{
return(GetAsExpressionTree(parsedNode.ChildNodes[1], parentExpNode));
}
//Binary operator
else if (parsedNode.ChildNodes.Count == 3)
{
BinaryOperatorBase binaryOp;
var opStr = parsedNode.ChildNodes[1].FindToken().ValueString;
switch (opStr)
{
// Math
case "+":
binaryOp = new AdditionOperator(parentExpNode);
break;
case "-":
binaryOp = new SubtractionOperator(parentExpNode);
break;
case "*":
binaryOp = new MultiplacationOperator(parentExpNode);
break;
case "/":
binaryOp = new DivisionOperator(parentExpNode);
break;
case "%":
binaryOp = new ModulusOperator(parentExpNode);
break;
case "^":
binaryOp = new PowerOperator(parentExpNode);
break;
// Bool
case "~==":
binaryOp = new LooseEqualsOperator(parentExpNode);
break;
case "~!=":
binaryOp = new LooseNotEqualsOperator(parentExpNode);
break;
case "==":
binaryOp = new EqualsOperator(parentExpNode);
break;
case "!=":
binaryOp = new NotEqualsOperator(parentExpNode);
break;
case "like":
binaryOp = new LikeOperator(parentExpNode);
break;
case "match":
binaryOp = new MatchOperator(parentExpNode);
break;
case ">":
binaryOp = new GreaterThanOperator(parentExpNode);
break;
case ">=":
binaryOp = new GreaterThanOrEqualOperator(parentExpNode);
break;
case "<":
binaryOp = new LessThanOperator(parentExpNode);
break;
case "<=":
binaryOp = new LessThanOrEqualOperator(parentExpNode);
break;
case "&&":
binaryOp = new AndOperator(parentExpNode);
break;
case "||":
binaryOp = new OrOperator(parentExpNode);
break;
default:
throw parsedNode.ChildNodes[1].GetException($"Unrecognized operator '{opStr}'");
}
binaryOp.LeftOperand = GetAsExpressionTree(parsedNode.ChildNodes[0], binaryOp);
binaryOp.RightOperand = GetAsExpressionTree(parsedNode.ChildNodes[2], binaryOp);
//Optimize
if (binaryOp.LeftOperand is LiteralValue && binaryOp.RightOperand is LiteralValue)
{
return(new LiteralValue(binaryOp.Eval(), parentExpNode));
}
return(binaryOp);
}
// Unary operator
else if (parsedNode.ChildNodes.Count == 2)
{
var opVal = parsedNode.ChildNodes[0].FindToken().Value;
UnaryOperatorBase unaryOp;
if (parsedNode.ChildNodes[0].FindToken().Value is TypeCode convertType)
{
unaryOp = new TypeConversionOperator(convertType, parentExpNode);
}
else
{
var opStr = opVal.ToString();
switch (opStr)
{
case "!":
unaryOp = new NotOperator(parentExpNode);
break;
//Property Checking
case "lengthof":
unaryOp = new LengthOperator(parentExpNode);
break;
case "typeof":
unaryOp = new TypeOperator(parentExpNode);
break;
default:
unaryOp = new GenericUnaryMathFunctionOperator(opStr, parentExpNode);
break;
}
}
unaryOp.Operand = GetAsExpressionTree(parsedNode.ChildNodes[1], unaryOp);
//Optimize
if (unaryOp.Operand is LiteralValue)
{
return(new LiteralValue(unaryOp.Eval(), parentExpNode));
}
return(unaryOp);
}
else
{
throw parsedNode.GetException($"Invalid number of tokens ({parsedNode.ChildNodes.Count})");
}
}
public bool IsBinaryOperator(TypeOperator op) => _typeOperations.Any(binaryOp => op == binaryOp.Operator);
/// <summary>
/// Default Constructor
/// </summary>
public Comparison()
{
Parameter = TypeParameter.GetCurrentHeal;
Operator = TypeOperator.LowerEqual;
Value = 100;
}
/// <summary>Create a type expression for lambda</summary> /// <param name="property">The name of property to compare</param> /// <param name="constant">The value to compare</param> /// <param name="item">TypeOperator object</param> /// <returns>Type of expression: Equal, NotEqual, GreatherThan, and so on</returns> private static Expression GenerateTypeExpression(Expression property, Expression constant, TypeOperator item) => item.Operation == Operators.Same ? Expression.Equal(property, constant) : item.Operation == Operators.NotSame ? Expression.NotEqual(property, constant) : item.Operation == Operators.Greather ? Expression.GreaterThan(property, constant) : item.Operation == Operators.GreaterThan ? Expression.GreaterThanOrEqual(property, constant) : item.Operation == Operators.Lower ? Expression.LessThan(property, constant) : item.Operation == Operators.LowerThan ? Expression.LessThanOrEqual(property, constant) : throw new InvalidOperationException();
public static Func <IWorkshopTree, IWorkshopTree, IWorkshopTree> DefaultFromOperator(TypeOperator op)
{
switch (op)
{
case TypeOperator.Add: return((l, r) => Element.Add(l, r));
case TypeOperator.And: return((l, r) => Element.And(l, r));
case TypeOperator.Divide: return((l, r) => Element.Divide(l, r));
case TypeOperator.Modulo: return((l, r) => Element.Modulo(l, r));
case TypeOperator.Multiply: return((l, r) => Element.Multiply(l, r));
case TypeOperator.Or: return((l, r) => Element.Or(l, r));
case TypeOperator.Pow: return((l, r) => Element.Pow(l, r));
case TypeOperator.Subtract: return((l, r) => Element.Subtract(l, r));
case TypeOperator.Equal: return((l, r) => Element.Compare(l, Elements.Operator.Equal, r));
case TypeOperator.GreaterThan: return((l, r) => Element.Compare(l, Elements.Operator.GreaterThan, r));
case TypeOperator.GreaterThanOrEqual: return((l, r) => Element.Compare(l, Elements.Operator.GreaterThanOrEqual, r));
case TypeOperator.LessThan: return((l, r) => Element.Compare(l, Elements.Operator.LessThan, r));
case TypeOperator.LessThanOrEqual: return((l, r) => Element.Compare(l, Elements.Operator.LessThanOrEqual, r));
case TypeOperator.NotEqual: return((l, r) => Element.Compare(l, Elements.Operator.NotEqual, r));
default: throw new NotImplementedException(op.ToString());
}
}
internal TypeExpression(IQuantityType left, IQuantityType right, TypeOperator op)
{
Left = left;
Right = right;
Operator = op;
}
public override ITypeOperation GetOperation(TypeOperator op, CodeType right) => GetOperation(() => base.GetOperation(op, right), toi => toi.GetOperation(op, right));
//делегат по операторам киев = 30, вода = 32, лайф = 43
public Operator(TypeOperator typeOperator, decimal pricePerSec)
{
TypeOperator = typeOperator;
PricePerSec = pricePerSec;
}
