protected override void WriteFunctionToSql(QueryExpression queryExpression)
{
switch (queryExpression)
{
case RandomFunctionExpression randomFunctionExpression:
Sql.Append($"FLOOR(RANDOM() * {int.MaxValue})::int");
return;
case LastInsertIdFunctionExpression lastInsertIdExpression:
Sql.Append("LASTVAL()");
return;
case TableExistsVirtualFunctionExpression tableExistsExpression:
ExpressionWriter.Visit(
Postgresql.Raw($@"SELECT 1
FROM pg_catalog.pg_class c
JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
WHERE n.nspname = current_schema()
AND c.relname = '{tableExistsExpression.Table.TableName.Replace("'", "\\'")}'
AND c.relkind = 'r' -- only tables")
);
return;
}
base.WriteFunctionToSql(queryExpression);
}
public void SystemToExpressionTest()
{
Project p = new Project();
MathSystem s1 = p.CurrentSystem;
// BUILD SYSTEM 1: sin(x^2)*2
Signal x = Binder.CreateSignal(); x.Label = "x";
Std.ConstrainAlwaysReal(x);
Signal x2 = StdBuilder.Square(x); x2.Label = "x2";
Signal sinx2 = StdBuilder.Sine(x2); sinx2.Label = "sinx2";
Signal sinx2t2 = sinx2 * IntegerValue.ConstantTwo;
s1.AddSignalTree(sinx2t2, true, true);
// EVALUATE SYSTEM 1 FOR x=1.5
x.PostNewValue(new RealValue(1.5));
p.SimulateInstant();
Assert.AreEqual(0, s1.BusCount, "A0");
Assert.AreEqual(5, s1.SignalCount, "A1");
Assert.AreEqual(3, s1.PortCount, "A2");
Assert.AreEqual("Std.Real(1.55614639377584)", sinx2t2.Value.ToString(), "A3");
// SERIALIZE SYSTEM 1 TO EXPRESSION
ExpressionWriter writer = new ExpressionWriter();
SystemReader reader = new SystemReader(writer);
reader.ReadSystem(s1);
string expr = writer.WrittenExpressions.Dequeue();
Console.WriteLine(expr);
// ....
}
public UpdateTableTests()
{
_sb = new StringBuilder();
_w = new ExpressionWriter(_sb, new SqlServerBuilderHelper());
_db = Setup.GetDb();
_builder = new UpdateTableBuilder <Post>(_db);
}
public UpdateTableTests()
{
_sb = new StringBuilder();
_w = new ExpressionWriter(_sb,new SqlServerBuilderHelper());
_db = Setup.GetDb();
_builder = new UpdateTableBuilder<Post>(_db);
}
protected virtual void WriteExpression(object o, TextWriter writer, Expression expr)
{
// NOTE: we don't dispose of the JsonWriter because we didn't create the text writer
JsonWriter jsonWriter = new JsonWriter(writer, !this.Settings.IsCompact, this.Settings.TypeAliases);
ExpressionWriter.Write(jsonWriter, this.Settings.OutputTypeInformation, expr);
}
protected override void WriteFunctionToSql(QueryExpression queryExpression)
{
switch (queryExpression)
{
case ConcatenateQueryExpression concatenateQueryExpression:
for (var i = 0; i < concatenateQueryExpression.Expressions.Length; i++)
{
ExpressionWriter.Visit(concatenateQueryExpression.Expressions[i]);
if (i < concatenateQueryExpression.Expressions.Length - 1)
{
Sql.Append(" || ");
}
}
return;
case LastInsertIdFunctionExpression lastInsertIdExpression:
Sql.Append("last_insert_rowid()");
return;
case TableExistsVirtualFunctionExpression tableExistsExpression:
ExpressionWriter.Visit(
QueryExpression.Select(
new[] { QueryExpression.Value(1) },
from: QueryExpression.Table("sqlite_master"),
where : QueryExpression.AndAlso(
QueryExpression.Compare(QueryExpression.Column("type"), ComparisonOperator.AreEqual, QueryExpression.Value("table")),
QueryExpression.Compare(QueryExpression.Column("name"), ComparisonOperator.AreEqual, QueryExpression.Value(tableExistsExpression.Table.TableName))
)
)
);
return;
}
base.WriteFunctionToSql(queryExpression);
}
public UpdateTableTests()
{
_sb = new StringBuilder();
_w = new ExpressionWriter(_sb,new SqlServerBuilderHelper());
var db = new Mock<IAccessDb>();
db.Setup(d => d.Provider).Returns(new SqlServerProvider());
_builder = new UpdateTableBuilder<Post>(db.Object);
}
public WhereCriteriaTests()
{
_sb = new StringBuilder();
_pm = new ParametersManager();
_fRm = new Mock<IDbProviderExpressionHelper>();
_fRm.Setup(d => d.EscapeName(It.IsAny<string>())).Returns((string v) => SqlServerProvider.EscapeIdentifier(v));
_fRm.Setup(d => d.FormatBoolean(It.IsAny<bool>())).Returns((bool v) => v==true?"1":"0");
_w = new ExpressionWriter(_sb,_fRm.Object,_pm);
}
public void WiteToStringWithReferenceTest()
{
var p = new People {
Name = "fireasy"
};
Expression <Func <Work, bool> > expression = (s) => s.People.Name == p.Name;
Console.WriteLine(ExpressionWriter.WriteToString(expression));
}
public WhereCriteriaTests()
{
_sb = new StringBuilder();
_pm = new ParametersManager();
_fRm = new Mock <IDbProviderExpressionHelper>();
_fRm.Setup(d => d.EscapeName(It.IsAny <string>())).Returns((string v) => SqlServerProvider.EscapeIdentifier(v));
_fRm.Setup(d => d.FormatBoolean(It.IsAny <bool>())).Returns((bool v) => v == true?"1":"0");
_w = new ExpressionWriter(_sb, _fRm.Object, _pm);
}
public UpdateTableTests()
{
_sb = new StringBuilder();
_w = new ExpressionWriter(_sb, new SqlServerBuilderHelper());
var db = new Mock <IAccessDb>();
db.Setup(d => d.Provider).Returns(new SqlServerProvider());
_builder = new UpdateTableBuilder <Post>(db.Object);
}
public override void Write(ExpressionWriter writer)
{
writer.Append("(");
writer.Append(this.LeftValue);
writer.Append(" ");
writer.Append(op);
writer.Append(" ");
writer.Append(this.RightValue);
writer.Append(")");
}
public override void Write(ExpressionWriter writer)
{
// due to issue: https://github.com/Azure/autorest/issues/975,
// date time offsets must be explicitly escaped before being passed to the filter
string datestring = this.DateTime.ToString("O");
var escaped_datestring = System.Uri.EscapeDataString(datestring);
writer.Append(string.Format("datetimeoffset'{0}'", escaped_datestring));
}
public void WiteToStringWithConstantTest()
{
var str = "fireasy";
var p = new People {
Age = 34
};
Expression <Func <People, bool> > expression = (s) => s.Name == str && s.Age == p.Age;
Console.WriteLine(ExpressionWriter.WriteToString(expression));
}
/// <summary>
/// 通过表达式计算出对应的缓存键。
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
private static string GetKey(Expression expression)
{
var evalExp = PartialEvaluator.Eval(expression, TranslateProviderBase.EvaluatedLocallyFunc);
var cacheKey = ExpressionWriter.WriteToString(evalExp);
//使用md5进行hash编码
var md5 = new MD5CryptoServiceProvider();
byte[] data = md5.ComputeHash(Encoding.Unicode.GetBytes(cacheKey));
return("$." + Convert.ToBase64String(data, Base64FormattingOptions.None));
}
public void WriteTest()
{
Expression <Func <People, bool> > expression = (s) => s.Age == 12;
using (var writer = new StringWriter(CultureInfo.InvariantCulture))
{
ExpressionWriter.Write(writer, expression);
Console.WriteLine(writer.ToString());
}
}
public string ToFilterString()
{
var expr_and = ToExpression();
var writer = new ExpressionWriter();
writer.Append(expr_and);
string text = writer.ToString();
return(text);
}
/// <summary>
/// Serializes an expression to a string
/// </summary>
/// <param name='context'>Data context used to generate type names for types.</param>
/// <param name="e">Expression to serialize</param>
/// <param name='inPath'>Whether or not the expression being written is part of the path of the URI.</param>
/// <param name="uriVersion">the request data service version for the uri</param>
/// <returns>serialized expression</returns>
internal static string ExpressionToString(DataServiceContext context, Expression e, bool inPath, ref Version uriVersion)
{
ExpressionWriter ew = new ExpressionWriter(context, inPath);
string serialized = ew.Translate(e);
WebUtil.RaiseVersion(ref uriVersion, ew.uriVersion);
if (ew.cantTranslateExpression)
{
throw new NotSupportedException(Strings.ALinq_CantTranslateExpression(e.ToString()));
}
return(serialized);
}
/// <summary>
/// Formats the <paramref name="expression"/>.
/// </summary>
/// <param name="expression">The expression to format.</param>
/// <param name="inCSharpNotation">If set to <see langword="true"/>,
/// the result will be returned in C# notation
/// (<see cref="ExpressionWriter"/> will be used).</param>
/// <returns>A string containing formatted expression.</returns>
public static string ToString(this Expression expression, bool inCSharpNotation)
{
if (!inCSharpNotation)
{
return(expression.ToString());
}
return(ExpressionWriter.Write(expression));
// // The old code
// string result = expression.ToString();
// result = Regex.Replace(result, @"value\([^)]+DisplayClass[^)]+\)\.", "");
// return result;
}
public void TestExpression()
{
var name = new AssemblyName("TestAssembly");
var assembly = AssemblyBuilder.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
var module = assembly.DefineDynamicModule("TestAssembly.dll");
var myClass = module.DefineType("MyClass");
var myField = myClass.DefineField("MyField", typeof(long), FieldAttributes.Public);
var myMethod = myClass.DefineMethod("MyMethod", MethodAttributes.Public, CallingConventions.HasThis, typeof(long), new Type[0]);
var expression = new Expression.Operation.Binary()
{
LeftOperand = new Expression.Parameter("Input"),
RightOperand = new Expression.Literal(10000),
Operator = new Syntax.Operator.Numerical.Addition()
};
var state = new ExpressionWriter.State()
{
FieldByName = new Dictionary <string, FieldInfo>()
{
["Input"] = myField
},
ArgumentsByName = new Dictionary <string, int>()
};
var generator = myMethod.GetILGenerator();
var writer = new ExpressionWriter(generator, state);
writer.WriteExpression(expression);
generator.Emit(OpCodes.Ret);
var myClassInfo = myClass.CreateType();
var myFieldInfo = myClass.GetField("MyField");
var myMethodInfo = myClassInfo.GetMethods()[0];
var myClassInstance = Activator.CreateInstance(myClass);
myFieldInfo.SetValue(myClassInstance, 3);
var output = myMethodInfo.Invoke(myClassInstance, new object[0]);
Assert.AreEqual(output, 10003);
}
/// <summary>
/// 通过表达式计算出对应的缓存键。
/// </summary>
/// <param name="expression">作为 Key 的 Lambda 表达式。</param>
/// <param name="prefix">用于区分缓存的前缀。</param>
/// <returns></returns>
public string Generate(Expression expression, params string[] prefix)
{
var evalExp = PartialEvaluator.Eval(expression, TranslateProviderBase.EvaluatedLocallyFunc);
var cacheKey = ExpressionWriter.WriteToString(evalExp);
//使用md5进行hash编码
var md5 = new MD5CryptoServiceProvider();
var data = md5.ComputeHash(Encoding.Unicode.GetBytes(cacheKey));
var sb = new StringBuilder();
foreach (var p in prefix)
{
if (!string.IsNullOrEmpty(p))
{
sb.AppendFormat("{0}:", p);
}
}
sb.Append(data.ToHex(true));
return(sb.ToString());
}
public override void Write(ExpressionWriter writer)
{
writer.Append("(not");
writer.Append(this.Expression);
writer.Append(")");
}
public void TestSetup()
{
_stringWriter = new StringWriter();
_jsonWriter = new JsonWriter(_stringWriter, false);
_exprWriter = new ExpressionWriter(_jsonWriter, true);
}
public override void Write(ExpressionWriter writer)
{
this.WriteItems(writer, " and ");
}
public override void Write(ExpressionWriter writer)
{
string s = string.Format("'{0}'", this.Content);
writer.Append(s);
}
/// <summary>Serializes an expression to a string.</summary>
/// <param name="expression">Expression to serialize</param>
/// <param name='inPath'>Whether or not the expression being written is part of the path of the URI.</param>
/// <returns>The serialized expression.</returns>
private string ExpressionToString(Expression expression, bool inPath)
{
return(ExpressionWriter.ExpressionToString(this.context, expression, inPath, ref this.uriVersion));
}
public override void Write(ExpressionWriter writer)
{
writer.Append(this.Integer.ToString());
}
public override void Write(ExpressionWriter writer)
{
writer.Append("null");
}
public override void Write(ExpressionWriter writer)
{
writer.Append(this.Name);
}
public void WriteToStringTest()
{
Expression <Func <People, bool> > expression = (s) => s.Age == 12;
Console.WriteLine(ExpressionWriter.WriteToString(expression));
}
public void WiteToStringWithLengthTest()
{
Expression <Func <People, bool> > expression = (s) => s.Name.Length == 4;
Console.WriteLine(ExpressionWriter.WriteToString(expression));
}
public void WiteToStringWithSubqueryTest()
{
Expression <Func <People, bool> > expression = (s) => s.Works.Count(t => t.Company == "aa") > 0;
Console.WriteLine(ExpressionWriter.WriteToString(expression));
}
