public override Value ExecNonDistributed(ExecContext context, Row input)
{
Debug.Assert(type_ != null);
Value expr = expr_().Exec(context, input);
// for distributed execution, we don't copy logic plan which means this expression
// is also not copied thus multiple threads may racing updating cacheVal_. Lock the
// code section to prevent it. This also redu
if (isCacheable_ && cachedValSet_)
{
var hset = cachedVal_ as HashSet <Value>;
hasNull_ = hset.Contains(null);
var in_cache_flag = !(expr is null) && hset.Contains(expr); // null in (1,null) false
// not in [.. null ..] = false
return(hasNot_ ? (!hasNull_ && !in_cache_flag) : in_cache_flag);
}
var set = new HashSet <Value>();
query_.physicPlan_.Exec(l =>
{
// it may have hidden columns but that's after [0]
set.Add(l[0]);
});
hasNull_ = set.Contains(null);
cachedVal_ = set;
cachedValSet_ = true;
bool in_flag = set.Contains(expr);
return(hasNot_ ? (!hasNull_ && !in_flag) : in_flag);
}
public override Value ExecNonDistributed(ExecContext context, Row input)
{
Debug.Assert(type_ != null);
Value expr = expr_().Exec(context, input);
// for distributed execution, we don't copy logic plan which means this expression
// is also not copied thus multiple threads may racing updating cacheVal_. Lock the
// code section to prevent it. This also redu
if (isCacheable_ && cachedValSet_)
{
return((cachedVal_ as HashSet <Value>).Contains(expr));
}
var set = new HashSet <Value>();
query_.physicPlan_.Exec(l =>
{
// it may have hidden columns but that's after [0]
set.Add(l[0]);
});
cachedVal_ = set;
cachedValSet_ = true;
return(set.Contains(expr));
}
public override object Visit(ExecContext ctx, Dictionary <string, object> table)
{
int intRes;
float floatRes;
if (var.StartsWith("\"") && var.EndsWith("\""))
{
return(var.Substring(1, var.Length - 2));
}
if (int.TryParse(var, out intRes))
{
return(intRes);
}
if (float.TryParse(var, out floatRes))
{
return(floatRes);
}
if (table.ContainsKey(var))
{
return(table[var]);
}
return(null);
}
public override Value Exec(ExecContext context, Row input)
{
string str = (string)args_()[0].Exec(context, input);
int times = (int)args_()[1].Exec(context, input);
return(string.Join("", Enumerable.Repeat(str, times)));
}
public override Value Init(ExecContext context, Row input)
{
pair_ = new AvgPair();
pair_.sum_ = arg_().Exec(context, input);
pair_.count_ = pair_.sum_ is null ? 0 : 1;
return(pair_);
}
public override Value Init(ExecContext context, Row input)
{
values_ = new AggStddevValues();
values_.vals_.Add(arg_().Exec(context, input));
type_ = new DoubleType();
return(values_);
}
public override object Visit(ExecContext ctx, Dictionary <string, object> table)
{
switch (s)
{
case "=":
op = Assign();
break;
case "*":
op = Binary("op_Multiply");
break;
case "/":
op = Binary("op_Division");
break;
case "%":
op = Binary("op_Modulus");
break;
case "+":
op = Binary("op_Addition");
break;
case "-":
op = Binary("op_Subtraction");
break;
case "?":
op = Nullable();
break;
}
return(op(lhs, rhs, table));
}
public override Value Accum(ExecContext context, Value old, Row input)
{
var arg = arg_().Exec(context, input);
Type ltype, rtype; ltype = typeof(int); rtype = typeof(int);
Debug.Assert(old != null);
AvgPair oldpair = old as AvgPair;
if (oldpair.sum_ is null)
{
pair_.sum_ = arg;
Debug.Assert(oldpair.count_ == 0);
if (arg != null)
{
pair_.count_ = 1;
}
}
else
{
dynamic lv = oldpair.sum_;
if (!(arg is null))
{
dynamic rv = arg;
pair_.sum_ = lv + rv;
pair_.count_ = oldpair.count_ + 1;
}
}
return(pair_);
}
public override Value Exec(ExecContext context, Row input)
{
dynamic val = arg_();
int hashval = val.GetHashCode();
return(hashval);
}
public List <Row> show()
{
bind(null);
// TBD: route to optimizer here
QueryOption queryOpt = new QueryOption();
physicPlan_ = logicPlan_.DirectToPhysical(queryOpt);
logicPlan_.ResolveColumnOrdinal(outputs_);
// actual execution
var finalplan = new PhysicCollect(physicPlan_);
physicPlan_ = finalplan;
var context = new ExecContext(queryOpt);
Console.WriteLine(physicPlan_.Explain());
finalplan.ValidateThis();
var code = finalplan.Open(context);
code += finalplan.Exec(null);
code += finalplan.Close();
return(finalplan.rows_);
}
// for distributed execution, we don't copy logic plan which means this expression
// is also not copied thus multiple threads may racing updating cacheVal_. A simple
// way is to Lock the code section to prevent it.
//
Value ExecDistributed(ExecContext context, Row input)
{
lock (this)
{
return(ExecNonDistributed(context, input));
}
}
public override object Exec(ExecContext context, Row input)
{
var desc = ExternalFunctions.set_[funcName_];
Debug.Assert(argcnt_ == desc.argcnt_);
dynamic fncode = desc.fn_;
List <dynamic> args = new List <dynamic>();
for (int i = 0; i < argcnt_; i++)
{
args.Add(args_()[i].Exec(context, input));
}
switch (argcnt_)
{
case 0: return(fncode());
case 1: return(fncode(args[0]));
case 2: return(fncode(args[0], args[1]));
case 3: return(fncode(args[0], args[1], args[2]));
default:
throw new NotImplementedException();
}
}
public override Value Exec(ExecContext context, Row input)
{
if (eval_() != null)
{
var eval = eval_().Exec(context, input);
for (int i = 0; i < when_().Count; i++)
{
if (eval.Equals(when_()[i].Exec(context, input)))
{
return(then_()[i].Exec(context, input));
}
}
}
else
{
for (int i = 0; i < when_().Count; i++)
{
if (when_()[i].Exec(context, input) is true)
{
return(then_()[i].Exec(context, input));
}
}
}
if (else_() != null)
{
return(else_().Exec(context, input));
}
return(null);
}
public override Value Exec(ExecContext context, Row input)
{
Value to = null;
dynamic from = child_().Exec(context, input);
switch (from)
{
case string vs:
switch (type_)
{
case DateTimeType td:
to = DateTime.Parse(from);
break;
default:
break;
}
break;
default:
to = from;
break;
}
return(to);
}
public override string ExecCode(ExecContext context, string input)
{
string lv = "(dynamic)" + l_().ExecCode(context, input);
string rv = "(dynamic)" + r_().ExecCode(context, input);
string code = null;
switch (op_)
{
case "+": code = $"({lv} + {rv})"; break;
case "-": code = $"({lv} - {rv})"; break;
case "*": code = $"({lv} * {rv})"; break;
case "/": code = $"({lv} / {rv})"; break;
case ">": code = $"({lv} > {rv})"; break;
case ">=": code = $"({lv} >= {rv})"; break;
case "<": code = $"({lv} < {rv})"; break;
case "<=": code = $"({lv} <= {rv})"; break;
case "=": code = $"({lv} == {rv})"; break;
case " and ": code = $"((bool){lv} && (bool){rv})"; break;
default:
throw new NotImplementedException();
}
return(code);
}
public override Value ExecNonDistributed(ExecContext context, Row input)
{
Debug.Assert(type_ != null);
if (isCacheable_ && cachedValSet_)
{
return(cachedVal_);
}
context.option_.PushCodeGenDisable();
Row r = null;
query_.physicPlan_.Exec(l =>
{
// exists check can immediately return after receiving a row
var prevr = r; r = l;
if (prevr != null)
{
throw new SemanticExecutionException("subquery more than one row returned");
}
});
context.option_.PopCodeGen();
cachedVal_ = (r != null) ? r[0] : null;
cachedValSet_ = true;
return(cachedVal_);
}
public override Value Exec(ExecContext context, Row input)
{
if (context is DistributedContext)
{
return(ExecDistributed(context, input));
}
return(ExecNonDistributed(context, input));
}
public override Value Accum(ExecContext context, Value old, Row input)
{
var arg = arg_().Exec(context, input);
AggStddevValues oldlist = old as AggStddevValues;
oldlist.vals_.Add(arg);
values_ = oldlist;
return(values_);
}
internal static void Run(Assembly assembly, SQLStatement stmt, ExecContext context)
{
// now we can execute it
var type = assembly.GetType("QueryCode");
var instance = assembly.CreateInstance("QueryCode");
var meth = type.GetMember("Run").First() as MethodInfo;
meth.Invoke(instance, new object[] { stmt, context });
}
public override Value Exec(ExecContext context, Row input)
{
var val = args_()[0].Exec(context, input);
if (val is null)
{
return(args_()[1].Exec(context, input));
}
return(val);
}
public override Value Accum(ExecContext context, Value old, Row input)
{
var arg = arg_().Exec(context, input);
if (arg != null)
{
count_ = old is null ? 1 : (long)old + 1;
}
return(count_);
}
public override Value Exec(ExecContext context, Row input)
{
dynamic number = args_()[0].Exec(context, input);
int decimals = (int)args_()[1].Exec(context, input);
if (number is null)
{
return(null);
}
return(Math.Round(number, decimals));
}
internal static void Run(CompilerResults cr, SQLStatement stmt, ExecContext context)
{
// now we can execute it
var assembly = cr.CompiledAssembly;
var queryCode = assembly.GetType("QueryCode");
var runmethod = queryCode.GetMethod("Run");
runmethod.Invoke(null, new object[2] {
stmt, context
});
}
internal void OpenSubQueries(ExecContext context)
{
foreach (var v in Subqueries(true))
{
v.query_.physicPlan_.Open(context);
}
foreach (var v in Subqueries(false))
{
v.query_.OpenSubQueries(context);
}
}
public override string ExecCode(ExecContext context, string input)
{
var str = str_.Replace("'", "\"");
if (type_ is DateTimeType)
{
var date = (DateTime)val_;
return($"(new DateTime({date.Ticks}))");
}
return(str);
}
public override Value Exec(ExecContext context, Row input)
{
string str = (string)args_()[0].Exec(context, input);
int start = (int)args_()[1].Exec(context, input) - 1;
int end = (int)args_()[2].Exec(context, input) - 1;
if (str is null)
{
return(null);
}
return(str.Substring(start, end - start + 1));
}
static void Main(string[] args)
{
// Dynamic proxy generation...
// Create a new proxy generation request
ProxyGenRequest req = new ProxyGenRequest();
// Set the location of the assembly to be generated
// leave empty ("") for current directory
req.ProxyPath = "";
// Set the name of the assembly (dll) that will be generated
req.ServiceName = "WeatherSvc";
// Set the url of the web service's WSDL file
req.WsdlUrl = "http://www.xmethods.net/sd/2001/TemperatureService.wsdl";
// Create a WSE mutator, generated proxies will expose the RequestContext
// and ResponseContext properties
ProxyPolicyMutator mutator = new ProxyPolicyMutator();
// Set the name of the proxy class generated
mutator.ProxyName = req.ServiceName;
// Create the proxy generator
ProxyGen pxyGen = new ProxyGen();
// Set the proxy generator's mutator
pxyGen.Mutator = mutator;
// Generate the proxy
string strAssembly = pxyGen.GenerateAssembly(req);
// Dynamic invocation...
// Set the parameter...note it MUST be in xml form
string strZipcode = "<string>10025</string>";
// Create an execution context
ExecContext ctx = new ExecContext();
// Set the fully qualified name of the web service proxy
// (FullQname = <Namespace>.<classname>"
ctx.ServiceName = req.Namespace + "." + req.ServiceName;
// Set the name of the assembly where the proxy class "lives"
ctx.Assembly = strAssembly;
// Set the name of the method to dynamically invoke
ctx.MethodName = "getTemp";
// Add any parameters
ctx.AddParameter(strZipcode);
// Create an Executor
Executor exec = new Executor();
// Execute using the context
object objRes = exec.Execute(ctx);
}
public override string ExecCode(ExecContext context, string input)
{
Debug.Assert(type_ != null);
if (isParameter_)
{
return(base.ExecCode(context, input));
}
else
{
return($"{input}[{ordinal_}]");
}
}
public override Value Exec(ExecContext context, Row input)
{
Debug.Assert(type_ != null);
if (isParameter_)
{
return(context.GetParam(tabRef_, ordinal_));
}
else
{
return(input[ordinal_]);
}
}
public override Value Exec(ExecContext context, Row input)
{
dynamic lv = l_().Exec(context, input);
dynamic rv = r_().Exec(context, input);
if (op_ != "is" && (lv is null || rv is null))
{
return(null);
}
switch (op_)
{
case "+": return(lv + rv);
case "-": return(lv - rv);
case "*": return(lv * rv);
case "/": return(lv / rv);
case "||": return(string.Concat(lv, rv));
case ">": return(lv > rv);
case ">=": return(lv >= rv);
case "<": return(lv < rv);
case "<=": return(lv <= rv);
case "=": return(lv == rv);
case "<>":
case "!=": return(lv != rv);
case "like": return(Utils.StringLike(lv, rv));
case "not like": return(!Utils.StringLike(lv, rv));
case " and ": return(lv && rv);
case " or ": // null handling is different - handled by itself
case "is":
return(lv is null && rv is null);
case "is not":
return(!(lv is null) && rv is null);
default:
throw new NotImplementedException();
}
}
