public virtual object Translate(LinqExpression expression, QueryOptions queryOptions)
{
this.rootCriteria = null;
this.options = queryOptions;
return TranslateInternal(expression);
}
public virtual object Translate(LinqExpression expression, ICriteria rootCriteria)
{
this.rootCriteria = rootCriteria;
this.options = null;
return TranslateInternal(expression);
}
internal static Et EtPush(Et table, Et lambda)
{
return Et.Call(
table,
MiPush,
lambda
);
}
private object TranslateInternal(LinqExpression expression)
{
Visit(expression); //ensure criteria
var visitor = new RootVisitor(rootCriteria, session, true);
visitor.Visit(expression);
return visitor.Results;
}
internal static Et EtPull(Et table, int n)
{
return Et.Call(
table,
MiPull,
Et.Constant(n, typeof(int))
);
}
public static FieldVisit CreateImplicit(Expr value)
{
return new FieldVisit
{
Type = FieldVisitType.Implicit,
Value = value
};
}
internal bool TryGetBoundExpression(LinqExpression linqExpression, out CqtExpression cqtExpression)
{
cqtExpression = _scopes
.Where(binding => binding.LinqExpression == linqExpression)
.Select(binding => binding.CqtExpression)
.FirstOrDefault();
return cqtExpression != null;
}
public static EktronExpression HandleIsNullOrEmpty(Expression obj, ReadOnlyCollection<Expression> arguments)
{
QueryBuildResult propResult = QueryBuildingVisitor.Build(arguments[0]);
StringPropertyExpression objectExpr = propResult.Expression as StringPropertyExpression;
return objectExpr.EqualTo(string.Empty);
}
public static Expr Index(Expr context, DynamicMetaObject target, DynamicMetaObject[] indexes)
{
return Expr.Invoke(
Expr.Constant((Func<CodeContext, object, object, object>)LuaOps.IndexMetamethod),
context,
Expr.Convert(target.Expression, typeof(object)),
Expr.Convert(indexes[0].Expression, typeof(object)));
}
public static Expr BinaryOp(Expr context, ExprType operation, DynamicMetaObject left, DynamicMetaObject right)
{
return Expr.Invoke(
Expr.Constant((Func<CodeContext, ExprType, object, object, object>)LuaOps.BinaryOpMetamethod),
context,
Expr.Constant(operation),
Expr.Convert(left.Expression, typeof(object)),
Expr.Convert(right.Expression, typeof(object)));
}
public static VariableVisit CreateMemberId(Expr @object, string identifier)
{
return new VariableVisit
{
Type = VariableType.MemberId,
Object = @object,
Identifier = identifier
};
}
public static FieldVisit CreateExplicit(Expr member, Expr value)
{
return new FieldVisit
{
Type = FieldVisitType.Explicit,
Member = member,
Value = value
};
}
public static VariableVisit CreateMemberExpr(Expr @object, Expr member)
{
return new VariableVisit
{
Type = VariableType.MemberExpr,
Object = @object,
Member = member
};
}
// Needed for Visual basic dynamic support
public override System.Dynamic.DynamicMetaObject BindInvokeMember(System.Dynamic.InvokeMemberBinder binder, System.Dynamic.DynamicMetaObject[] args)
{
var parameters = new System.Linq.Expressions.Expression[]
{
System.Linq.Expressions.Expression.Constant(binder.Name)
};
var callMethod = CallMethod(getValueMethod, parameters);
return callMethod;
}
public static EktronExpression HandleStringContains(
Expression obj, ReadOnlyCollection<Expression> arguments)
{
QueryBuildResult objectResult = QueryBuildingVisitor.Build(obj);
QueryBuildResult argResult = QueryBuildingVisitor.Build(arguments[0]);
StringPropertyExpression objectExpr = objectResult.Expression as StringPropertyExpression;
StringValueExpression argExpr = argResult.Expression as StringValueExpression;
return objectExpr.Contains(argExpr.Value, WordForms.Inflections);
}
public override System.Dynamic.DynamicMetaObject BindSetMember(System.Dynamic.SetMemberBinder binder, System.Dynamic.DynamicMetaObject value)
{
var parameters = new System.Linq.Expressions.Expression[]
{
System.Linq.Expressions.Expression.Constant(binder.Name),
value.Expression,
};
var callMethod = CallMethod(setValueMethod, parameters);
return callMethod;
}
public static Expr Call(Expr context, DynamicMetaObject target, DynamicMetaObject[] args)
{
var expression = Expr.Invoke(
Expr.Constant((Func<CodeContext, object, object[], object>)LuaOps.CallMetamethod),
context,
Expr.Convert(target.Expression, typeof(object)),
Expr.NewArrayInit(
typeof(object),
args.Select(arg => Expr.Convert(arg.Expression, typeof(object)))));
return expression;
}
public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
var combinedArgs = new Expr[args.Length + 1];
combinedArgs[0] = target.Expression;
Array.Copy(args.Select(a => a.Expression).ToArray(), 0, combinedArgs, 1, args.Length);
var restrictions = target.Restrictions.Merge(BindingRestrictions.Combine(args));
var expression =
Expr.Dynamic(
context.CreateInvokeBinder(new CallInfo(args.Length)),
typeof(object),
combinedArgs);
return new DynamicMetaObject(expression, restrictions);
}
public IEnumerable<DataNamFlattened> GetNamsByParams(string namNumber, string roomNumber, string vlan,
string building, string departmentNumber)
{
var retval = new List<DataNamFlattened>();
var hasNamNumber = !(String.IsNullOrEmpty(namNumber) || namNumber.Equals("0"));
var hasRoomNumber = !(String.IsNullOrEmpty(roomNumber) || roomNumber.Equals("0"));
var hasVlan = !(String.IsNullOrEmpty(vlan) || vlan.Equals("0"));
var hasBuilding = !(String.IsNullOrEmpty(building) || building.Equals("0"));
var hasDepartmentNumber = !(String.IsNullOrEmpty(departmentNumber) || departmentNumber.Equals("0"));
var hasSearchParameters = hasNamNumber || hasRoomNumber || hasVlan || hasBuilding || hasDepartmentNumber
? true
: false;
if (hasSearchParameters)
{
NamSearchExpression = PredicateBuilder.True<DataNamFlattened>();
if (hasNamNumber)
{
NamSearchExpression = NamSearchExpression.And(p => p.NamNumber.Equals(namNumber));
}
if (hasRoomNumber)
{
NamSearchExpression = NamSearchExpression.And(p => p.Room.Equals(roomNumber));
}
if (hasVlan)
{
NamSearchExpression =
NamSearchExpression.And(p => p.Vlan.Equals(vlan));
}
if (hasBuilding)
{
NamSearchExpression =
NamSearchExpression.And(p => p.Building.Equals(building));
}
if (hasDepartmentNumber)
{
NamSearchExpression =
NamSearchExpression.And(p => p.DepartmentNumber.Equals(departmentNumber));
}
retval = _dataNamRepository
.Queryable
.Where(NamSearchExpression)
.OrderBy(t => t.NamNumber)
.ToList();
}
return retval;
}
public static Expr ConvertToNumberAndCheck(CodeContext context, Expr expression, string format, params object[] args)
{
var numberVar = Expr.Variable(typeof(double));
var assignNumber = Expr.Assign(numberVar, ConvertToNumber(context, expression));
return Expr.Block(
new[] {numberVar},
assignNumber,
Expr.Condition(
Expr.Invoke(
Expr.Constant((Func<double, bool>)Double.IsNaN), numberVar),
Expr.Block(
Expr.Throw(Expr.New(MemberInfos.NewRuntimeException, Expr.Constant(context), Expr.Constant(format), Expr.Constant(args))),
Expr.Constant(Double.NaN)),
numberVar));
}
public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
var combinedArgs = new Expr[args.Length + 1];
combinedArgs[0] = target.Expression;
Array.Copy(args.Select(a => a.Expression).ToArray(), 0, combinedArgs, 1, args.Length);
var restrictions = target.Restrictions.Merge(BindingRestrictions.Combine(args));
Expr expression =
Expr.Dynamic(
context.CreateInvokeBinder(new CallInfo(args.Length)),
typeof(object),
combinedArgs);
expression = MetamethodFallbacks.WrapStackTrace(expression, context,
new FunctionStack(context,null, null, context.CurrentVariableIdentifier + "." + Name));
return new DynamicMetaObject(expression, restrictions);
}
private object TranslateInternal(LinqExpression expression)
{
try
{
Visit(expression); //ensure criteria
var visitor = new RootVisitor(rootCriteria, session, true);
visitor.Visit(expression);
if (_Log.IsDebugEnabled)
_Log.DebugFormat("Translated Criteria: {0}", rootCriteria.ToString());
return visitor.Results;
}
catch (Exception ex)
{
var tmp = rootCriteria != null ? rootCriteria.ToString() : "{null}";
_Log.ErrorFormat("Linq translation failed, current criteria: {0}", tmp);
throw;
}
}
Expr FallbackIfNumberIsNan(Expr numExpr)
{
// If we have performed a string to number conversion check that conversion went well by checking
// number for NaN. If conversion failed do metatable fallback. Also assign to temp variable for single evaluation.
var numVar = Expr.Variable(typeof(double));
var expr = Expr.IfThenElse(
Expr.Invoke(Expr.Constant((Func<double, bool>)Double.IsNaN), numVar),
Expr.Invoke(
Expr.Constant((Func<LuaContext, object, object>)LuaOps.UnaryMinusMetamethod),
Expr.Constant(context),
Expr.Constant(Operation),
Expr.Convert(numExpr, typeof(object))),
numVar);
return Expr.Block(
new[] { numVar },
Expr.Assign(numVar, numExpr),
expr);
}
protected internal override void CheckSemantics(AstHelper astHelper)
{
FunctionName.CheckSemantics(astHelper);
foreach (Expression expression in Parameters)
expression.CheckSemantics(astHelper);
Type[] parameterTypes = Parameters.Select(param => param.Type).ToArray();
if (!astHelper.Errors.Check(new FunctionNotDefinedError(FunctionName.Name, parameterTypes,
astHelper.Functions, Start)))
{
FunctionReference functionReference = astHelper.Functions[FunctionName.Name, parameterTypes];
_type = functionReference.ReturnType;
_pointer = functionReference.Function;
}
else
{
// if there is any error
_type = typeof (Null);
_pointer = MAst.Empty();
}
}
Expr FallbackIfNumberIsNan(Expr numExpr)
{
// If we have performed a string to number conversion check that conversion went well by checking
// number for NaN. If conversion failed do metatable fallback. Also assign to temp variable for single evaluation.
var numVar = Expr.Variable(typeof(double));
var expr = Expr.IfThenElse(
Expr.Invoke(Expr.Constant((Func<double, bool>)Double.IsNaN), numVar),
MetamethodFallbacks.WrapStackTrace(
Expr.Invoke(
Expr.Constant((Func<CodeContext, object, object>)LuaOps.UnaryMinusMetamethod),
Expr.Constant(context),
Expr.Constant(Operation),
Expr.Convert(numExpr, typeof(object))), context,
new FunctionStack(context, null, null, context.CurrentVariableIdentifier + "." + Constant.UNARYMINUS_METAMETHOD)),
numVar);
return Expr.Block(
new[] { numVar },
Expr.Assign(numVar, numExpr),
expr);
}
public static SM_TuitionVouchs Fetch(int page, int rowCount, System.Linq.Expressions.Expression <Func <SM_TuitionVouch, bool> > exp, params object[] values)
{
return(EF.DataPortal.Fetch <SM_TuitionVouchs>(new PagigExpress {
Page = page, RowCount = rowCount, Lambda = LambdaExpression.Create <SM_TuitionVouch>(exp, values)
}));
}
public static System.Linq.IQueryable <TEntity> Find <TEntity>(this Orc.EntityFramework.Repositories.IEntityRepository <TEntity> repository, System.Linq.Expressions.Expression <System.Func <TEntity, bool> > predicate)
where TEntity : class
{
}
internal InvocationExpression(System.Linq.Expressions.Expression lambda, IList<System.Linq.Expressions.Expression> arguments, System.Type returnType)
{
this._lambda = lambda;
this._arguments = arguments;
this._returnType = returnType;
}
public Meta GetMetaObject(Et parameter)
{
return new IObjMeta(parameter, this);
}
public virtual System.Linq.IQueryable <TEntity> GetQuery(System.Linq.Expressions.Expression <System.Func <TEntity, bool> > predicate)
{
}
/// <summary>
/// 查询
/// </summary>
/// <param name="whereLambda"></param>
/// <returns></returns>
public IQueryable <T> LoadEntities(System.Linq.Expressions.Expression <Func <T, bool> > whereLambda)
{
Db.Configuration.ValidateOnSaveEnabled = false;
return(Db.Set <T>().Where <T>(whereLambda));
}
public FakeDbAsyncEnumerable(System.Linq.Expressions.Expression expression)
: base(expression)
{
}
public static Customer GetUnique(System.Linq.Expressions.Expression <Func <Customer, bool> > predicate)
{
return(Customer.CreateCriteria().Add(Expression.Where <Customer>(predicate)).UniqueResult <Customer>());
}
public CompanyJobDescriptionPoco GetSingle(System.Linq.Expressions.Expression <Func <CompanyJobDescriptionPoco, bool> > where, params System.Linq.Expressions.Expression <Func <CompanyJobDescriptionPoco, object> >[] navigationProperties)
{
IQueryable <CompanyJobDescriptionPoco> pocos = GetAll().AsQueryable();
return(pocos.Where(where).FirstOrDefault());
}
public static FI_FieldGrp Fetch(System.Linq.Expressions.Expression <Func <FI_FieldGrp, bool> > exp, params object[] values)
{
LambdaExpression lambda = LambdaExpression.Create <FI_FieldGrp>(exp, values);
return(EF.DataPortal.Fetch <FI_FieldGrp>(lambda));
}
public IList <CompanyJobDescriptionPoco> GetList(System.Linq.Expressions.Expression <Func <CompanyJobDescriptionPoco, bool> > where, params System.Linq.Expressions.Expression <Func <CompanyJobDescriptionPoco, object> >[] navigationProperties)
{
throw new NotImplementedException();
}
public virtual async Task <IEnumerable <T> > GetByCondition(System.Linq.Expressions.Expression <Func <T, bool> > predicate)
{
return(await _uow.Context.Set <T>().Where(predicate).ToListAsync());
}
/// <summary>
/// 分页
/// </summary>
/// <typeparam name="s"></typeparam>
/// <param name="pageIdex"></param>
/// <param name="pageSize"></param>
/// <param name="toalCount"></param>
/// <param name="whereLambda"></param>
/// <param name="orderbyLambda"></param>
/// <param name="isAsc">true:表示升序, false：降序</param>
/// <returns></returns>
public IQueryable <T> LoadPageEntities <s>(int pageIdex, int pageSize, out int toalCount, System.Linq.Expressions.Expression <Func <T, bool> > whereLambda, System.Linq.Expressions.Expression <Func <T, s> > orderbyLambda, bool isAsc)
{
var temp = Db.Set <T>().Where <T>(whereLambda);
toalCount = temp.Count();
if (isAsc)//升序
{
temp = temp.OrderBy <T, s>(orderbyLambda).Skip <T>((pageIdex - 1) * pageSize).Take <T>(pageSize);
}
else
{
temp = temp.OrderByDescending <T, s>(orderbyLambda).Skip <T>((pageIdex - 1) * pageSize).Take <T>(pageSize);
}
return(temp);
}
public static System.Collections.Generic.IList <PurchaseOrderLine> GetList(System.Linq.Expressions.Expression <Func <PurchaseOrderLine, bool> > predicate)
{
return(PurchaseOrderLine.CreateCriteria().Add(Expression.Where <PurchaseOrderLine>(predicate)).List <PurchaseOrderLine>());
}
public TResult Execute <TResult>(System.Linq.Expressions.Expression expression)
{
return(_inner.Execute <TResult>(expression));
}
public static EQ_EquTypes Fetch(System.Linq.Expressions.Expression <Func <EQ_EquType, bool> > exp, params object[] values)
{
LambdaExpression lambda = LambdaExpression.Create <EQ_EquType>(exp, values);
return(EF.DataPortal.Fetch <EQ_EquTypes>(lambda));
}
public IQueryable <TElement> CreateQuery <TElement>(System.Linq.Expressions.Expression expression)
{
return(new FakeDbAsyncEnumerable <TElement>(expression));
}
public System.Threading.Tasks.Task <TResult> ExecuteAsync <TResult>(System.Linq.Expressions.Expression expression, System.Threading.CancellationToken cancellationToken)
{
return(System.Threading.Tasks.Task.FromResult(Execute <TResult>(expression)));
}
public static SM_TuitionVouch Fetch(System.Linq.Expressions.Expression <Func <SM_TuitionVouch, bool> > exp, params object[] values)
{
LambdaExpression lambda = LambdaExpression.Create <SM_TuitionVouch>(exp, values);
return(EF.DataPortal.Fetch <SM_TuitionVouch>(lambda));
}
public object Execute(System.Linq.Expressions.Expression expression)
{
return(_inner.Execute(expression));
}
public static PurchaseOrderLine GetUnique(System.Linq.Expressions.Expression <Func <PurchaseOrderLine, bool> > predicate)
{
return(PurchaseOrderLine.CreateCriteria().Add(Expression.Where <PurchaseOrderLine>(predicate)).UniqueResult <PurchaseOrderLine>());
}
public IQueryable CreateQuery(System.Linq.Expressions.Expression expression)
{
return(new FakeDbAsyncEnumerable <TEntity>(expression));
}
public static System.Collections.Generic.IList <Customer> GetList(System.Linq.Expressions.Expression <Func <Customer, bool> > predicate)
{
return(Customer.CreateCriteria().Add(Expression.Where <Customer>(predicate)).List <Customer>());
}
public static TEntity SingleOrDefault <TEntity>(this Orc.EntityFramework.Repositories.IEntityRepository <TEntity> repository, System.Linq.Expressions.Expression <System.Func <TEntity, bool> > predicate = null)
where TEntity : class
{
}
public IQueryable <tb_candidato> Find(System.Linq.Expressions.Expression <Func <tb_candidato, bool> > where)
{
return(_DAO.Find(where));
}
Meta IDynamicMetaObjectProvider.GetMetaObject(Et parameter)
{
return new IObjMeta(parameter, this);
}
/// <inheritdoc/>
public DynamicMetaObject GetMetaObject(Expression parameter)
{
return new ObservableNodeDynamicMetaObject(parameter, this);
}
public static System.Linq.Expressions.Expression <System.Func <TEntity, bool> > GetValidPredicate <TEntity>(this System.Linq.Expressions.Expression <System.Func <TEntity, bool> > predicate)
{
}
public static Product GetUnique(System.Linq.Expressions.Expression <Func <Product, bool> > predicate)
{
return(Product.CreateCriteria().Add(Expression.Where <Product>(predicate)).UniqueResult <Product>());
}
public IEnumerable <T> Get(System.Linq.Expressions.Expression <Func <T, bool> > predicate)
{
return(_unitOfWork.Context.Set <T>().Where(predicate).AsEnumerable <T>());
}
public static void Test()
{
#region "low" number of args doesn't require naming
_arg0();
_arg1(1);
_arg1(_a1);
_arg2(_a1, _a2);
_arg3(_a1, _a2, _a3);
_arg4(_a1, _a2, _a3, _a4);
// Named literals
_arg5(a1: 1, a2: 2, a3: 3, a4: 4, a5: 5);
_arg6(a1: 1, a2: 2, a3: 3, a4: 4, a5: 5, a6: 6);
// Named literals + variables
_arg4(_a1, _a2, a3: 3, a4: 4);
_arg5(_a1, _a2, a3: 3, a4: 4, _a5);
#endregion
#region diagnostic for too many unnamed args
/* TooManyUnnamedArgs */ _arg5(1, 2, 3, 4, 5) /**/;
/* TooManyUnnamedArgs */ _arg6(1, 2, 3, 4, 5, 6) /**/;
_arg3(/* LiteralArgShouldBeNamed(a1) */ 1 /**/, /* LiteralArgShouldBeNamed(a2) */ 2 /**/, /* LiteralArgShouldBeNamed(a3) */ 3 /**/);
_arg3(a1: 1, /* LiteralArgShouldBeNamed(a2) */ 2 /**/, /* LiteralArgShouldBeNamed(a3) */ 3 /**/);
#endregion
#region verbatim identifiers
funcWithVerbatims(@int, @class, /* LiteralArgShouldBeNamed(@params) */ 3 /**/, p, p);
/* TooManyUnnamedArgs */ funcWithVerbatims(p, p, p, p, p) /**/;
// These should pass:
funcWithVerbatims(@int, @class, @params, @name, @a5);
funcWithVerbatims(@int, p, p, p, p);
#endregion
#region all named args is usually preferred if there are lots of args
_arg6(
a1: 1,
a2: 2,
a3: 3,
a4: 4,
a5: 5,
a6: 6
);
#endregion
#region named args don't count against the unnamed args budget
_arg5(a1: 1, p, p, p, p);
_arg6(a1: 1, a2: 2, p, p, p, p);
#endregion
#region arguments that are literals with the correct name don't count against the budget
int a1 = 11;
int a3 = 13;
int A1 = 101; // upper case doesn't matter
_arg5(a1, p, p, p, p);
_arg5(p, p, a3, p, p);
_arg6(A1, p, a3, p, p, p);
#endregion
#region member accesses can also serve as psuedo-names
var thing = new Thing();
_arg5(p, p, p, thing.a4, p);
_arg5(p, p, p, thing.nested.a4, p);
_arg5(p, p, p, thing.m_a4, p);
_arg5(p, p, p, thing.nested._a4, p);
#endregion
#region need to have enough named args, though
/* TooManyUnnamedArgs */ _arg6(a1: 1, 2, 3, 4, 5, 6) /**/;
/* TooManyUnnamedArgs */ _arg6(1, a2: 2, 3, 4, 5, 6) /**/;
#endregion
#region params don't count against the unnamed args budget
funcWithParams(p, p, p);
funcWithParams(p, p, p, p);
funcWithParams(p, p, p, p, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26);
#endregion
#region delegates
((delegate0Args)null)();
((delegate1Args)null)(1);
/* TooManyUnnamedArgs */ ((delegate5Args)null)(p, p, p, p, p) /**/;
((delegate5Args)null)(a1 : 1, p, p, p, p);
#endregion
#region class constructors should behave the same way
// these aren't InvocationExpressions like the above but should
// behave just the same.
new SomeClass();
new SomeClass(1);
new SomeClass(p, p);
/* TooManyUnnamedArgs */ new SomeClass(p, p, p, p, p) /**/;
new SomeClass(a1: 1, p, p, p, p);
#endregion
#region expressions should not trigger named argument diagnostics
// See: https://stackoverflow.com/a/10133102
System.Linq.Expressions.Expression <Func <int> > expression5args = () => _arg5_ret(p, p, p, p, p);
System.Linq.Expressions.Expression <Func <int> > expression2args = () => _arg2_ret(p, p);
System.Linq.Expressions.Expression <Func <int> > expression1args = () => _arg1_ret(p);
// Do it again with constants to test 'LiteralArgShouldBeNamed'
System.Linq.Expressions.Expression <Func <int> > expression5args = () => _arg5_ret(1, 2, 3, 4, 5);
System.Linq.Expressions.Expression <Func <int> > expression2args = () => _arg2_ret(1, 2);
System.Linq.Expressions.Expression <Func <int> > expression1args = () => _arg1_ret(1);
// Try with various nested function calls
System.Linq.Expressions.Expression <Func <int> > nest1 =
() => _arg2_ret(1, _arg2_ret(1, 2));
System.Linq.Expressions.Expression <Func <int, int> > nest2 =
(x) => _arg1_ret(_arg2_ret(x, 2));
System.Linq.Expressions.Expression <Func <int> > nest3 =
() => _arg2_ret(_arg2_ret(1, 2), _arg1_ret(1));
System.Linq.Expressions.Expression <Func <int> > nest4 =
() => _arg5_ret(
_arg2_ret(_arg2_ret(1, _arg2_ret(1, 2)), _arg1_ret(1)),
_arg5_ret(1, 2, 3, 4, 5),
_arg2_ret(_arg2_ret(_arg2_ret(_arg5_ret(1, 2, 3, 4, 5), 2), 2), 2),
4,
_arg2_ret(1, 2)
);
System.Linq.Expressions.Expression <Func <int> > nest5 =
() => _arg2_ret(1, 2 + _arg2_ret(1, 2));
System.Linq.Expressions.Expression <Func <int> > nest6 =
() => _arg2_ret(1, _arg2_ret(1, 2) * _arg2_ret(1, 2));
#endregion
}
public static System.Linq.Expressions.Expression[] MakeExpression (Arguments args, BuilderContext ctx)
{
if (args == null || args.Count == 0)
return null;
var exprs = new System.Linq.Expressions.Expression [args.Count];
for (int i = 0; i < exprs.Length; ++i) {
Argument a = args.args [i];
exprs[i] = a.Expr.MakeExpression (ctx);
}
return exprs;
}
public static EQ_EquTypes Fetch(int page, int rowCount, System.Linq.Expressions.Expression <Func <EQ_EquType, bool> > exp, params object[] values)
{
return(EF.DataPortal.Fetch <EQ_EquTypes>(new PagigExpress {
Page = page, RowCount = rowCount, Lambda = LambdaExpression.Create <EQ_EquType>(exp, values)
}));
}
public static FI_FieldGrps Fetch(int page, int rowCount, System.Linq.Expressions.Expression <Func <FI_FieldGrp, bool> > exp, params object[] values)
{
return(EF.DataPortal.Fetch <FI_FieldGrps>(new PagigExpress {
Page = page, RowCount = rowCount, Lambda = LambdaExpression.Create <FI_FieldGrp>(exp, values)
}));
}
public static System.Collections.Generic.IList <Product> GetList(System.Linq.Expressions.Expression <Func <Product, bool> > predicate)
{
return(Product.CreateCriteria().Add(Expression.Where <Product>(predicate)).List <Product>());
}
