public void Disjunction() { ICriteriaBuilder cb = EJBContainer.Instance.EntityManager.GetCriteriaBuilder(); ICriteriaQuery cq = cb.CreateQuery(); IRoot r = cq.From("Students"); IPredicate criteria = cb.Disjunction(); IParameterExpression pr = cb.Parameter(System.Data.SqlDbType.Int, "3"); criteria = cb.Or(criteria, cb.Equal(r.Get("SequenceNumber"), pr) ); pr = cb.Parameter(System.Data.SqlDbType.Int, "'Jonas'"); criteria = cb.Or(criteria, cb.Equal(r.Get("FirstName"), pr) ); pr = cb.Parameter(System.Data.SqlDbType.Int, "'Petraitis'"); criteria = cb.Or(criteria, cb.Equal(r.Get("LastName"), pr) ); Assert.AreEqual("Students.SequenceNumber = 3 OR Students.FirstName = 'Jonas' OR Students.LastName = 'Petraitis'", criteria.ExpressionValue); }
public DoubleParameterCompilableContainer( IParameterExpression <TFirst> first, IParameterExpression <TSecond> second) { _parameter1 = first; _parameter2 = second; }
/// <summary> /// Adjusts the parameter properties. /// </summary> /// <param name="parameterExpr">The parameter expr.</param> /// <param name="parameter">The parameter.</param> protected override void AdjustParameterProperties(IParameterExpression parameterExpr, DbParameter parameter) { var oracleParameter = parameter as OracleParameter; if (parameter.Value == null) { parameter.Value = DBNull.Value; return; } var type = parameter.Value.GetType(); if (type.IsEnum) { parameter.DbType = DbType.Int32; parameter.Value = Convert.ToInt32(parameter.Value); return; } if (type == typeof(Boolean)) { parameter.Value = (((bool)parameter.Value) ? 1 : 0); return; } if (type == typeof(Guid)) { oracleParameter.OracleType = OracleType.Char; oracleParameter.Size = 36; parameter.Value = parameter.Value.ToString(); return; } if (type == typeof(byte[])) { if (((byte[])parameter.Value).Length > 8000) { oracleParameter.OracleType = OracleType.Blob; } return; } if (type == typeof(DateTime)) { oracleParameter.OracleType = OracleType.DateTime; return; } if (type != typeof(string)) { return; } var stringParameterExpr = parameterExpr as StringParameterExpression; if (stringParameterExpr.IsUnicode) { oracleParameter.OracleType = parameter.Value.ToString().Length > 2000 ? OracleType.NClob : OracleType.NVarChar; } else { oracleParameter.OracleType = parameter.Value.ToString().Length > 4000 ? OracleType.Clob : OracleType.VarChar; } return; }
public ConditionExpression(IResultExpression <TConditionParameter, bool> condition, IParameterlessResultExpression <TResult> ifExpression, IParameterlessResultExpression <TResult> elseExpression) : base(Native.Expression.Condition(condition.GetNativeExpression(), ifExpression.GetNativeExpression(), elseExpression.GetNativeExpression())) { _parameter = condition.GetParameter(); }
/// <summary> /// Adjusts the parameter properties. /// </summary> /// <param name="parameterExpr">The parameter expr.</param> /// <param name="parameter">The parameter.</param> protected override void AdjustParameterProperties(IParameterExpression parameterExpr, DbParameter parameter) { var sqlParameter = parameter as SqlParameter; if (parameter.Value == null) { parameter.Value = DBNull.Value; return; } var type = parameter.Value.GetType(); if (type.IsEnum) { parameter.DbType = DbType.Int32; parameter.Value = Convert.ToInt32(parameter.Value); return; } if (type == typeof(Boolean)) { parameter.Value = (((bool)parameter.Value) ? 1 : 0); return; } if (type == typeof(Guid)) { sqlParameter.SqlDbType = SqlDbType.UniqueIdentifier; return; } if (type == typeof(byte[])) { if (((byte[])parameter.Value).Length > 8000) { sqlParameter.SqlDbType = SqlDbType.Image; } return; } if (type == typeof(DateTime)) { sqlParameter.SqlDbType = SqlDbType.DateTime; return; } if (type != typeof(string)) { return; } var stringParameterExpr = parameterExpr as StringParameterExpression; if (stringParameterExpr.IsUnicode) { sqlParameter.SqlDbType = parameter.Value.ToString().Length > 4000 ? SqlDbType.NText : SqlDbType.NVarChar; } else { sqlParameter.SqlDbType = parameter.Value.ToString().Length > 8000 ? SqlDbType.Text : SqlDbType.VarChar; } return; }
public void ParameterExpressoin_IntType() { ICriteriaBuilder cb = EJBContainer.Instance.EntityManager.GetCriteriaBuilder(); ICriteriaQuery cq = cb.CreateQuery(); IRoot r = cq.From("Students"); IParameterExpression pr = cb.Parameter(System.Data.SqlDbType.Int, "3"); IPredicate exp = cb.Equal(r.Get("SequenceNumber"), pr); Assert.AreEqual("Students.SequenceNumber = 3", exp.ExpressionValue); }
public void ParameterExpressoin_StringType() { ICriteriaBuilder cb = EJBContainer.Instance.EntityManager.GetCriteriaBuilder(); ICriteriaQuery cq = cb.CreateQuery(); IRoot r = cq.From("Students"); IParameterExpression pr = cb.Parameter(System.Data.SqlDbType.VarChar, "Jonas"); IPredicate exp = cb.Equal(r.Get("FirstName"), pr); Assert.AreEqual("Students.FirstName = 'Jonas'", exp.ExpressionValue); }
/// <summary> /// Push the function expression on the call stack /// </summary> /// <param name="qualifiedName">Name of function call</param> /// <param name="exp">Function Call expression</param> public bool Push(string qualifiedName, IParameterExpression exp) { _stack.Add(new Tuple <string, IParameterExpression>(qualifiedName, exp)); _lastIndex++; if (_limitCheck != null) { var node = exp as AstNode; _limitCheck(node, _lastIndex); } return(true); }
/// <summary> /// Push the function expression on the call stack /// </summary> /// <param name="qualifiedName">Name of function call</param> /// <param name="exp">Function Call expression</param> public bool Push(string qualifiedName, IParameterExpression exp) { _stack.Add(new Tuple<string, IParameterExpression>(qualifiedName, exp)); _lastIndex++; if (_limitCheck != null) { var node = exp as AstNode; _limitCheck(node, _lastIndex); } return true; }
/// <summary> /// Adds the parameter. /// </summary> /// <param name="parameterExpr">The parameter expr.</param> /// <param name="parameterCollection">The parameter collection.</param> /// <param name="setParameterValueOnly">if set to <c>true</c> [set parameter value only].</param> protected void AddParameter(IParameterExpression parameterExpr, DbParameterCollection parameterCollection, bool setParameterValueOnly) { if (setParameterValueOnly) { foreach (DbParameter parameter in parameterCollection) { if (parameter.Value != null) { continue; } parameter.Value = parameterExpr.Value ?? DBNull.Value; AdjustParameterProperties(parameterExpr, parameter); break; } } else { var parameter = GetDbProviderFactory().CreateParameter(); parameter.ParameterName = ToParameterName("p" + (parameterCollection.Count + 1)); parameter.Value = parameterExpr.Value; AdjustParameterProperties(parameterExpr, parameter); parameterCollection.Add(parameter); } }
/// <summary> /// Adjusts the parameter properties. /// </summary> /// <param name="parameterExpr">The parameter expr.</param> /// <param name="parameter">The parameter.</param> protected abstract void AdjustParameterProperties(IParameterExpression parameterExpr, DbParameter parameter);
/// <summary> /// Parses parameters. /// </summary> /// <param name="pexp">The expression that can hold parameters.</param> /// <param name="expectParenthesis">Whether or not to expect parenthis to designate the start of the parameters.</param> /// <param name="advanceAfter">Whether or not to advance after the ending left parenthesis</param> /// <param name="enableNewLineAsEnd">Whether or not to treat a newline as end</param> public void ParseParameters(IParameterExpression pexp, bool expectParenthesis, bool advanceAfter, bool enableNewLineAsEnd = false) { int totalParameters = 0; if (_tokenIt.NextToken.Token == Tokens.LeftParenthesis) expectParenthesis = true; if(expectParenthesis) _tokenIt.Expect(Tokens.LeftParenthesis); bool passNewLine = !enableNewLineAsEnd; var endTokens = enableNewLineAsEnd ? Terminators.ExpFluentFuncExpParenEnd : Terminators.ExpFuncExpEnd; while (true) { // Check for end of statment or invalid end of script. if (IsEndOfParameterList(Tokens.RightParenthesis, enableNewLineAsEnd)) break; if (_tokenIt.NextToken.Token == Tokens.Comma) _tokenIt.Advance(); var exp = ParseExpression(endTokens, true, false, true, passNewLine); pexp.ParamListExpressions.Add(exp); totalParameters++; _context.Limits.CheckParserFunctionParams(exp, totalParameters); // Check for end of statment or invalid end of script. if (IsEndOfParameterList(Tokens.RightParenthesis, enableNewLineAsEnd)) break; // Advance. Expect(Tokens.Comma); } if(expectParenthesis) _tokenIt.Expect(Tokens.RightParenthesis); }
public SingleParameterCompilableContainer(IParameterExpression <TParameter> parameter) { _parameter = parameter; }