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;
}
