static string GetPreconditionOperandString(OperandValue operand, string @operator, List <string> parameterNames)
{
if (operand.Trait == null)
{
if (operand.Enum != null)
{
return($"{operand.Enum.name}.{operand.Value}");
}
if (parameterNames.Contains(operand.Parameter))
{
return($"stateData.GetTraitBasedObjectId({operand.Parameter}Index)");
}
return(operand.Value);
}
var precondition = $"{operand.Trait.name}Buffer[{operand.Parameter}Object.{operand.Trait.name}Index]";
if (!string.IsNullOrEmpty(operand.TraitProperty.Name))
{
precondition += $".{operand.TraitProperty.Name}";
var operandPropertyType = operand.TraitProperty.Type;
if (IsListType(operandPropertyType))
{
if (IsComparisonOperator(@operator))
{
precondition += ".Length";
}
}
}
return(precondition);
}
private static Condition Binary(BinaryOperator binaryOperator)
{
OperandProperty opProperty = binaryOperator.LeftOperand as OperandProperty;
OperandValue opValue = binaryOperator.RightOperand as OperandValue;
if (ReferenceEquals(binaryOperator, null) || ReferenceEquals(opValue, null))
{
return(null);
}
switch (binaryOperator.OperatorType)
{
case BinaryOperatorType.Equal:
return(new Condition(opProperty.PropertyName, Operator.Equals, opValue.Value));
case BinaryOperatorType.NotEqual:
return(new Condition(opProperty.PropertyName, Operator.DoesntEquals, opValue.Value));
case BinaryOperatorType.Greater:
return(new Condition(opProperty.PropertyName, Operator.IsGreaterThan, opValue.Value));
case BinaryOperatorType.Less:
return(new Condition(opProperty.PropertyName, Operator.IsLessThan, opValue.Value));
case BinaryOperatorType.LessOrEqual:
return(new Condition(opProperty.PropertyName, Operator.IsLessThanOrEqualto, opValue.Value));
case BinaryOperatorType.GreaterOrEqual:
return(new Condition(opProperty.PropertyName, Operator.IsGreaterThanOrEqualto, opValue.Value));
default:
throw new FilterException(string.Format(Resource.UnsupportedOperatorError, binaryOperator.OperatorType, "binary"));
}
}
private static Condition Function(FunctionOperator functionOperator)
{
if (ReferenceEquals(functionOperator, null))
{
return(null);
}
OperandProperty opProperty = functionOperator.Operands.Count == 3
? functionOperator.Operands[1] as OperandProperty : functionOperator.Operands[0] as OperandProperty;
OperandValue opValue = functionOperator.Operands.Count > 1
? functionOperator.Operands.Count == 3
? functionOperator.Operands[2] as OperandValue
: functionOperator.Operands[1] as OperandValue
: null;
switch (functionOperator.OperatorType)
{
case FunctionOperatorType.Contains:
return(new Condition(opProperty.PropertyName, Operator.Contains, opValue.Value));
case FunctionOperatorType.StartsWith:
return(new Condition(opProperty.PropertyName, Operator.StartsWith, opValue.Value));
case FunctionOperatorType.EndsWith:
return(new Condition(opProperty.PropertyName, Operator.EndsWith, opValue.Value));
case FunctionOperatorType.IsNullOrEmpty:
return(new Condition(opProperty.PropertyName, Operator.IsNullOrEmpty));
default:
throw new FilterException(string.Format(Resource.UnsupportedOperatorError, functionOperator.OperatorType, "function"));
}
}
/// <summary>
/// 重新设定表达式，
/// 如果是LIKE表达式，自动在前后加上%%
/// </summary>
/// <param name="operandValue">需要被设定的表达式</param>
private void resetOperandValue(CriteriaOperator critalOperator)
{
if (critalOperator is GroupOperator)
{
//多个表达式连接在一起的
GroupOperator groupOperator = critalOperator as GroupOperator;
foreach (CriteriaOperator cOperator in groupOperator.Operands)
{
resetOperandValue(cOperator);
}
}
else if (critalOperator is UnaryOperator)
{
//一元表达式，例如NOT，一元表示下还可能包括二元表达式
UnaryOperator unaryOperator = critalOperator as UnaryOperator;
resetOperandValue(unaryOperator.Operand);
}
//二元表达式，需要被格式化的表达式
else if (critalOperator is BinaryOperator)
{
BinaryOperator binaryOperator = critalOperator as BinaryOperator;
if (binaryOperator.OperatorType == BinaryOperatorType.Like)
{
OperandValue operandValue = binaryOperator.RightOperand as OperandValue;
if (operandValue.Value is string)
{
if (((string)operandValue.Value).IndexOf("%") < 0)
{
((OperandValue)((BinaryOperator)critalOperator).RightOperand).Value = "%" + operandValue.Value.ToString() + "%";
}
}
}
}
}
private ActionScope InitializeScope(int formID, int actionID, Dictionary <int, string> operandID_Value)
{
FormInstance formInstance = new FormMetaBLL().GetFormMetaDescriptions(formID);
BaseActionInstance action = formInstance.GetEventAction(actionID);
if (action == null)
{
throw new FormGenerationException(string.Format(
"Action not found in form actions (ActionID = {0}, FormID = {1})",
actionID,
formInstance.Form.FormID
));
}
List <OperandValue> operandValues = new List <OperandValue>();
foreach (int operandID in operandID_Value.Keys)
{
string serializedValue = operandID_Value[operandID];
PropertyValueType valueType = formInstance.GetOperandValueType(operandID);
OperandValue operand = new OperandValue(operandID, valueType, serializedValue);
operandValues.Add(operand);
}
return(new ActionScope(action, formInstance, operandValues));
}
protected void grid_CustomJSProperties(object sender, ASPxGridViewClientJSPropertiesEventArgs e)
{
var grid = sender as ASPxGridView;
var filterExpression = ((GridViewDataColumn)grid.Columns["BirthDate"]).FilterExpression;
if (!string.IsNullOrEmpty(filterExpression))
{
var co = (GroupOperator)CriteriaOperator.Parse(filterExpression);
DateTime start = new DateTime();
DateTime end = new DateTime();
foreach (BinaryOperator op in co.Operands)
{
OperandValue val = (OperandValue)op.RightOperand;
if (op.OperatorType == BinaryOperatorType.GreaterOrEqual)
{
start = (DateTime)val.Value;
}
else if (op.OperatorType == BinaryOperatorType.Less)
{
end = ((DateTime)val.Value).AddDays(-1);
}
else if (op.OperatorType == BinaryOperatorType.LessOrEqual)
{
end = (DateTime)val.Value;
}
}
var dates = new Dates();
dates.DateFrom = start;
dates.DateTo = end;
e.Properties["cpDates"] = dates;
}
}
public override void Visit(OperandValue theOperand)
{
if (theOperand.Value == null)
{
isCriteriaOperatorValid = false;
}
}
private static FunctionOperator createOperandValue(object requiredValue, FunctionOperatorType operatorType)
{
CriteriaOperatorCollection operands = new CriteriaOperatorCollection();
OperandValue operandValue = new OperandValue(requiredValue);
operands.Add(operandValue);
return(new FunctionOperator(operatorType, operands));
}
public CriteriaOperator Visit(OperandValue theOperand)
{
if (theOperand.Value == null)
{
return(null);
}
return(theOperand);
}
protected override CriteriaOperator Visit(OperandValue theOperand)
{
if (theOperand.Value is DevExpress.Xpo.IXPSimpleObject)
{
object key = ((DevExpress.Xpo.IXPSimpleObject)theOperand.Value).Session.GetKeyValue(theOperand.Value);
return(new OperandValue(key));
}
return(base.Visit(theOperand));
}
protected override void Process(OperandValue operand) {
base.Process(operand);
if(operand.Value != null) {
ITypeInfo valueTypeInfo = typesInfo.FindTypeInfo(operand.Value.GetType());
if((valueTypeInfo != null) && valueTypeInfo.IsDomainComponent) {
operand.Value = valueTypeInfo.KeyMember.GetValue(operand.Value);
}
}
}
protected virtual CriteriaOperator VisitValue(OperandValue theOperand)
{
var constantValue = theOperand as ConstantValue;
if (!ReferenceEquals(constantValue, null))
{
Values.Add(constantValue.Value.ToString());
}
return(theOperand);
}
protected override object Visit(OperandValue theOperand)
{
if (theOperand.Value != null)
{
var ti = GetPersistentTypeInfo(theOperand);
if (ti != null)
return new OperandValue(ti.KeyMember.GetValue(theOperand.Value));
}
return base.Visit(theOperand);
}
public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
BinaryOperator op = values[0] as BinaryOperator;
if (object.ReferenceEquals(op, null))
{
return(null);
}
OperandValue operandValue = op.RightOperand as OperandValue;
return(operandValue.Value);
}
object IValueConverter.Convert(object value, Type targetType, object parameter, string language)
{
BinaryOperator op = value as BinaryOperator;
if (object.ReferenceEquals(op, null))
{
return(0d);
}
OperandValue operandValue = op.RightOperand as OperandValue;
return(operandValue.Value);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
BinaryOperator binaryOperator = value as BinaryOperator;
if (ReferenceEquals(binaryOperator, null))
{
return(null);
}
OperandValue rightOperand = binaryOperator.RightOperand as OperandValue;
return(rightOperand.Value);
}
private string ProcessOperandValue(OperandValue operandValue)
{
var parameterName = "param" + AggregatedParameters.Count;
var parameterValue = operandValue.Value;
if (parameterValue == null)
{
return("null");
}
AggregatedParameters.Add(parameterName, parameterValue);
return(":" + parameterName);
}
string ICriteriaVisitor <string> .Visit(OperandValue theOperand)
{
var c = theOperand as ConstantValue;
var str = ReferenceEquals(c, null)
? theOperand.LegacyToString()
: SqlExpressionHelper.GetCorrectStringValue(c.Value);
if (string.IsNullOrEmpty(str))
{
return(str);
}
return(_isNeedUpper ? string.Format("upper({0})", str) : str);
}
/// <summary>
/// Finds the application object by replication key.
/// </summary>
/// <param name="classType">Type of the class.</param>
/// <param name="reference">The reference.</param>
/// <param name="objectSpace">The object space.</param>
/// <returns>Application object</returns>
private static object findApplicationObjectByReplicationKey(Type classType,
IObjectReference reference, IObjectSpace objectSpace)
{
object result = null;
var modelClass = XafDeltaModule.XafApp.FindModelClass(classType);
if (modelClass != null && reference.ReplicationKey != null)
{
var replicationKeyMember = ExtensionsHelper.GetReplicationKeyMember(modelClass.TypeInfo);
var replicationKeyIsCaseInsensitive = modelClass.ReplicationKeyIsCaseInsensitive();
var replicationKeyIsSpaceInsensitive = modelClass.ReplicationKeyIsSpaceInsensitive();
if (replicationKeyMember != null)
{
CriteriaOperator opLeft = new OperandProperty(replicationKeyMember.Name);
CriteriaOperator opRight = new OperandValue(reference.ReplicationKey);
if (replicationKeyIsCaseInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Upper, opLeft);
opRight = new FunctionOperator(FunctionOperatorType.Upper, opRight);
}
if (replicationKeyIsSpaceInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Replace, opLeft,
new OperandValue(" "), new OperandValue(String.Empty));
opRight = new FunctionOperator(FunctionOperatorType.Replace, opRight,
new OperandValue(" "), new OperandValue(String.Empty));
}
var keyCriteria = new BinaryOperator(opLeft, opRight, BinaryOperatorType.Equal);
if (replicationKeyMember.MemberInfo.IsAliased)
{
var list = objectSpace.CreateCollection(modelClass.TypeInfo.Type);
result = (from c in list.Cast <object>()
let objKeyValue = replicationKeyMember.MemberInfo.GetValue(c)
where keysMatches(objKeyValue, reference.ReplicationKey,
replicationKeyIsCaseInsensitive, replicationKeyIsSpaceInsensitive)
select c).FirstOrDefault();
}
else
{
result = objectSpace.FindObject(classType, keyCriteria, true);
}
}
}
return(result);
}
private static Condition Between(BetweenOperator betweenOperator)
{
OperandProperty opProperty = betweenOperator.TestExpression as OperandProperty;
OperandValue opValue = betweenOperator.BeginExpression as OperandValue;
OperandValue opValue2 = betweenOperator.EndExpression as OperandValue;
var listType = typeof(List <>).MakeGenericType(opValue.Value.GetType());
var list = Activator.CreateInstance(listType, 2);
var method = listType.GetMethod("Add");
method.Invoke(list, new object[] { opValue.Value });
method.Invoke(list, new object[] { opValue2.Value });
return(new Condition(opProperty.PropertyName, Operator.IsBetween, list));
}
void PatchOperator(OperandValue opr, DateTime date, string range, bool isFirst)
{
if (((object)opr) == null)
{
return;
}
switch (range)
{
case "Day": opr.Value = date.AddDays(isFirst ? 1 : -1); break;
case "Week": opr.Value = date.AddDays(isFirst ? 7 : -7); break;
case "Month": opr.Value = date.AddMonths(isFirst ? 1 : -1); break;
}
}
protected string GetDisplayText(OperandProperty firstOperand, CriteriaOperator op)
{
OperandValue v = op as OperandValue;
if (!ReferenceEquals(v, null))
{
return(node.OwnerControl.FilterColumns.GetValueScreenText(firstOperand, v.Value));
}
OperandProperty p = op as OperandProperty;
if (!ReferenceEquals(p, null))
{
return(GetDisplayText(p));
}
return(CriteriaOperator.ToString(op));
}
object GetFilterValueByColumn(GridColumn column)
{
BinaryOperator bo = column.FilterInfo.FilterCriteria as BinaryOperator;
if (ReferenceEquals(bo, null))
{
return(null);
}
OperandValue value = bo.RightOperand as OperandValue;
if (ReferenceEquals(value, null))
{
return(null);
}
return(value.Value);
}
private void ProjectSearchLookUpEdit_EditValueChanged(object sender, EventArgs e)
{
if (ProjectSearchLookUpEdit.EditValue == null)
{
return;
}
Guid projectId = projectId = (Guid)ProjectSearchLookUpEdit.EditValue;;
if (projectId == Guid.Empty)
{
return;
}
// iteration reload data
ProjectIterationSearchLookUpEdit.ReloadData(new BinaryOperator("ProjectId", projectId));
// iteration reload data
ProjectModuleSearchLookUpEdit.ReloadData(new BinaryOperator("ProjectId", projectId));
// owner reload data
EventHandler <EventArgs <Guid> > handler = OnProjectChange;
if (handler != null)
{
handler(OwnerIdLookUpEdit, new EventArgs <Guid>(projectId));
}
EntityBindingSource.Current.AsDyanmic().ProjectId = projectId;
CriteriaOperator theOperator = Context.GetFilter("ProjectIterationId");
if (theOperator == null)
{
return;
}
if (!(theOperator is BinaryOperator))
{
return;
}
OperandValue operandValue = ((BinaryOperator)theOperator).RightOperand as OperandValue;
if (operandValue.Value is Guid)
{
EntityBindingSource.Current.AsDyanmic().ProjectIterationId = operandValue.Value;
}
}
private void ExtractOne(Dictionary <string, object> dict, CriteriaOperator op)
{
BinaryOperator opBinary = op as BinaryOperator;
if (ReferenceEquals(opBinary, null))
{
return;
}
OperandProperty opProperty = opBinary.LeftOperand as OperandProperty;
OperandValue opValue = opBinary.RightOperand as OperandValue;
if (ReferenceEquals(opBinary, null) || ReferenceEquals(opValue, null))
{
return;
}
dict.Add(opProperty.PropertyName, opValue.Value);
}
protected override void Process(OperandValue theOperand)
{
base.Process(theOperand);
if (theOperand.Value != null)
{
ITypeInfo typeInfo = XafTypesInfo.Instance.FindTypeInfo(theOperand.Value.GetType());
if (typeInfo != null)
{
if (typeInfo.DefaultMember != null)
{
theOperand.Value = typeInfo.DefaultMember.GetValue(theOperand.Value).ToString();
return;
}
}
theOperand.Value = theOperand.Value.ToString();
}
}
public ContainsFunction(string propertyName, OperandValue operandValue)
{
OperatorType = FunctionOperatorType.Custom;
Operands.Clear();
Operands.Add(new OperandValue(ContainsFunctionName));
Operands.Add(new OperandProperty(propertyName));
// string[] strings = operandValue.Value.ToString().Split(' ');
// string value = "";
// for (int i = 0; i < strings.Length; i++)
// {
// strings[i] = strings[i].Trim() + " NEAR ";
// value += strings[i];
// }
// value = value.Substring(0, value.LastIndexOf(" NEAR "));
// operandValue.Value=value;
operandValue.Value = "\"" + operandValue.Value + "\"";
Operands.Add(operandValue);
}
/// <summary>
/// Metodo que ternona los parametros de entrada del
/// SP
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
private OperandValue[] GetOperands(object[] list)
{
if (list != null && list.Length > 0)
{
var parametersLegth = list.Length;
OperandValue[] parameters = new OperandValue[parametersLegth];
for (int parameter = 0; parameter < parametersLegth; parameter++)
{
parameters[parameter] = new OperandValue(list[parameter]);
}
return(parameters);
}
else
{
return(null);
}
}
protected override void Process(OperandValue theOperand)
{
base.Process(theOperand);
if (theOperand.Value != null)
{
ITypeInfo typeInfo = XafTypesInfo.Instance.FindTypeInfo(theOperand.Value.GetType());
if (typeInfo != null)
{
if (typeInfo.DefaultMember != null)
{
theOperand.Value = typeInfo.DefaultMember.GetValue(theOperand.Value).ToString();
return;
}
}
theOperand.Value = theOperand.Value.ToString();
}
}
public ContainsFunction(string propertyName, OperandValue operandValue)
{
OperatorType = FunctionOperatorType.Custom;
Operands.Clear();
Operands.Add(new OperandValue(ContainsFunctionName));
Operands.Add(new OperandProperty(propertyName));
// string[] strings = operandValue.Value.ToString().Split(' ');
// string value = "";
// for (int i = 0; i < strings.Length; i++)
// {
// strings[i] = strings[i].Trim() + " NEAR ";
// value += strings[i];
// }
// value = value.Substring(0, value.LastIndexOf(" NEAR "));
// operandValue.Value=value;
operandValue.Value = "\"" + operandValue.Value + "\"";
Operands.Add(operandValue);
}
public OperandSelectorPopup(SerializedProperty property, IList <ParameterDefinition> parameters, bool allowParameter, bool allowTrait, Action <SerializedProperty> onExpectedTypeChanged = null, Type expectedType = null, string expectedUnknownType = default)
{
m_Property = property;
m_EditingOperand = new OperandValue()
{
Parameter = property.FindPropertyRelative("m_Parameter").stringValue,
Trait = property.FindPropertyRelative("m_Trait").objectReferenceValue as TraitDefinition,
TraitPropertyId = property.FindPropertyRelative("m_TraitPropertyId").intValue,
Enum = property.FindPropertyRelative("m_Enum").objectReferenceValue as EnumDefinition,
Value = property.FindPropertyRelative("m_Value").stringValue
};
m_Parameters = parameters;
m_OnExpectedTypeChanged = onExpectedTypeChanged;
m_AllowParameter = allowParameter;
m_AllowTrait = allowTrait;
m_ExpectedType = expectedType;
m_ExpectedUnknownType = expectedUnknownType;
if (allowParameter || expectedType == null || expectedType == typeof(UnityEngine.GameObject))
{
m_ParameterValues = m_Parameters.Select(param => param.Name).ToList();
}
else if (m_AllowTrait)
{
m_ParameterValues = m_Parameters.Where(param => param.RequiredTraits.Any()).Select(param => param.Name).ToList();
}
else
{
m_ParameterValues = new List <string>();
// Add only parameters that allow valid fields selection
foreach (var parameter in parameters)
{
if (parameter.RequiredTraits.Any(t => t.Properties.Any(IsValidField)))
{
m_ParameterValues.Add(parameter.Name);
}
}
}
}
private void SetContextProject()
{
if (EntityBindingSource.Current == null)
{
return;
}
CriteriaOperator theOperator = Context.GetFilter("ProjectId");
if (theOperator == null)
{
return;
}
if (!(theOperator is BinaryOperator))
{
return;
}
OperandValue operandValue = ((BinaryOperator)theOperator).RightOperand as OperandValue;
if (operandValue.Value is Guid)
{
((Katrin.Domain.Impl.ProjectTask)EntityBindingSource.Current).ProjectId = (Guid)operandValue.Value;
}
}
private void SetContextProject()
{
if (EntityBindingSource.Current == null)
{
return;
}
CriteriaOperator theOperator = Context.GetFilter("ProjectId");
if (theOperator == null)
{
return;
}
if (!(theOperator is BinaryOperator))
{
return;
}
OperandValue operandValue = ((BinaryOperator)theOperator).RightOperand as OperandValue;
if (operandValue.Value is Guid)
{
EntityBindingSource.Current.AsDyanmic().ProjectId = operandValue.Value;
}
}
/// <summary>
/// Finds the application object by replication key.
/// </summary>
/// <param name="classType">Type of the class.</param>
/// <param name="reference">The reference.</param>
/// <param name="objectSpace">The object space.</param>
/// <returns>Application object</returns>
private static object findApplicationObjectByReplicationKey(Type classType,
IObjectReference reference, IObjectSpace objectSpace)
{
object result = null;
var modelClass = XafDeltaModule.XafApp.FindModelClass(classType);
if (modelClass != null && reference.ReplicationKey != null)
{
var replicationKeyMember = ExtensionsHelper.GetReplicationKeyMember(modelClass.TypeInfo);
var replicationKeyIsCaseInsensitive = modelClass.ReplicationKeyIsCaseInsensitive();
var replicationKeyIsSpaceInsensitive = modelClass.ReplicationKeyIsSpaceInsensitive();
if (replicationKeyMember != null)
{
CriteriaOperator opLeft = new OperandProperty(replicationKeyMember.Name);
CriteriaOperator opRight = new OperandValue(reference.ReplicationKey);
if (replicationKeyIsCaseInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Upper, opLeft);
opRight = new FunctionOperator(FunctionOperatorType.Upper, opRight);
}
if (replicationKeyIsSpaceInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Replace, opLeft,
new OperandValue(" "), new OperandValue(String.Empty));
opRight = new FunctionOperator(FunctionOperatorType.Replace, opRight,
new OperandValue(" "), new OperandValue(String.Empty));
}
var keyCriteria = new BinaryOperator(opLeft, opRight, BinaryOperatorType.Equal);
if(replicationKeyMember.MemberInfo.IsAliased)
{
var list = objectSpace.CreateCollection(modelClass.TypeInfo.Type);
result = (from c in list.Cast<object>()
let objKeyValue = replicationKeyMember.MemberInfo.GetValue(c)
where keysMatches(objKeyValue, reference.ReplicationKey,
replicationKeyIsCaseInsensitive, replicationKeyIsSpaceInsensitive)
select c).FirstOrDefault();
}
else
result = objectSpace.FindObject(classType, keyCriteria, true);
}
}
return result;
}
/// <summary>
/// Преобразование указанного значения в строку формата Variant
/// </summary>
/// <param name="value">Значение</param>
/// <returns>Строка, представляющее значение в формате Variant</returns>
/// <exception cref="ArgumentException">Значение не поддерживает интерфейс IConvertible</exception>
public static string ValueToString(object value)
{
if (value == null) return null;
string typeString, valueString;
if (value is IConvertible)
{
typeString = Type.GetTypeCode(value.GetType()).ToString();
valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
}
else
throw new ArgumentException();
object t = new OperandProperty(typeString);
object v = new OperandValue(valueString);
return string.Concat(t.ToString(), ":", v.ToString());
}
public object Visit(OperandValue theOperand) {
/* Nothing special to do here.. */
return theOperand;
}
public Term(OperandValue e)
{
_functor = e.Value;
fType = e.FType;
}
public virtual object Visit(OperandValue theOperand)
{
return null;
}
/// <contentfrom cref="ICriteriaVisitor.Visit(OperandValue)"/>
public object Visit(OperandValue theOperand)
{
return theOperand;
}
/// <contentfrom cref="ISecurityRule.GetSelectMemberExpression" />
public bool GetSelectMemberExpression(DevExpress.Xpo.SecurityContext context, XPClassInfo classInfo, XPMemberInfo memberInfo, out CriteriaOperator expression)
{
CriteriaOperator subExpression;
expression = null;
foreach (ISecurityRule rule in rules)
if (rule.GetSelectMemberExpression(context, classInfo, memberInfo, out subExpression))
{
if (ReferenceEquals(expression, null))
expression = subExpression;
else if (!CriteriaOperator.CriterionEquals(expression, subExpression))
{
expression = new OperandValue(null);
return true;
}
}
return !ReferenceEquals(expression, null);
}
Object yyparse (yyInput yyLex) {
if (yyMax <= 0) yyMax = 256;
int yyState = 0;
int [] yyStates = new int[yyMax];
Object yyVal = null;
Object [] yyVals = new Object[yyMax];
int yyToken = -1;
int yyErrorFlag = 0;
int yyTop = 0;
goto skip;
yyLoop:
yyTop++;
skip:
for(;; ++yyTop) {
if(yyTop >= yyStates.Length) {
int[] i = new int[yyStates.Length + yyMax];
yyStates.CopyTo(i, 0);
yyStates = i;
Object[] o = new Object[yyVals.Length + yyMax];
yyVals.CopyTo(o, 0);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
yyDiscarded:
for(;;) {
int yyN;
if ((yyN = yyDefRed[yyState]) == 0) {
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyToken)) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
yyToken = -1;
if (yyErrorFlag > 0) -- yyErrorFlag;
goto yyLoop;
}
if((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0
&& yyN < yyTable.Length && yyCheck[yyN] == yyToken)
yyN = yyTable[yyN];
else
switch(yyErrorFlag) {
case 0:
yyerror("syntax error");
goto case 1;
case 1: case 2:
yyErrorFlag = 3;
do {
if((yyN = yySindex[yyStates[yyTop]]) != 0
&& (yyN += Token.yyErrorCode) >= 0 && yyN < yyTable.Length
&& yyCheck[yyN] == Token.yyErrorCode) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
goto yyLoop;
}
} while (--yyTop >= 0);
yyerror("irrecoverable syntax error");
goto yyDiscarded;
case 3:
if (yyToken == 0)
yyerror("irrecoverable syntax error at end-of-file");
yyToken = -1;
goto yyDiscarded;
}
}
int yyV = yyTop + 1 - yyLen[yyN];
yyVal = yyV > yyTop ? null : yyVals[yyV];
switch(yyN) {
case 1:
#line 54 "grammar.y"
{ result = new CriteriaOperator[0]; }
break;
case 2:
#line 55 "grammar.y"
{ result = ((List<CriteriaOperator>)yyVals[-1+yyTop]).ToArray(); }
break;
case 3:
#line 59 "grammar.y"
{ yyVal = new List<CriteriaOperator>(new CriteriaOperator[] {(CriteriaOperator)yyVals[0+yyTop]}); }
break;
case 4:
#line 60 "grammar.y"
{ yyVal = yyVals[-2+yyTop]; ((List<CriteriaOperator>)yyVal).Add((CriteriaOperator)yyVals[0+yyTop]); }
break;
case 5:
#line 64 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 6:
#line 65 "grammar.y"
{
OperandProperty prop2 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop4 = (OperandProperty)yyVals[0+yyTop];
prop2.PropertyName = '<' + prop2.PropertyName + '>' + prop4.PropertyName;
yyVal = prop2;
}
break;
case 7:
#line 74 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 8:
#line 75 "grammar.y"
{ yyVal = new OperandProperty("^"); }
break;
case 9:
#line 79 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 10:
#line 80 "grammar.y"
{
OperandProperty prop1 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop3 = (OperandProperty)yyVals[0+yyTop];
prop1.PropertyName += '.' + prop3.PropertyName;
yyVal = prop1;
}
break;
case 11:
#line 89 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 12:
#line 93 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-5+yyTop], (CriteriaOperator)yyVals[-3+yyTop], agg.AggregateType, agg.AggregatedExpression);
}
break;
case 13:
#line 97 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-4+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 14:
#line 101 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Exists, null); }
break;
case 15:
#line 102 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, Aggregate.Exists, null); }
break;
case 18:
#line 110 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 19:
#line 111 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 20:
#line 112 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 21:
#line 113 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 22:
#line 114 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Min, null); }
break;
case 23:
#line 115 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Max, null); }
break;
case 24:
#line 116 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Avg, null); }
break;
case 25:
#line 117 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Sum, null); }
break;
case 26:
#line 121 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 27:
#line 122 "grammar.y"
{
string paramName = (string)yyVals[0+yyTop];
if(string.IsNullOrEmpty(paramName)) {
OperandValue param = new OperandValue();
resultParameters.Add(param);
yyVal = param;
} else {
bool paramNotFound = true;
foreach(OperandValue v in resultParameters) {
OperandParameter p = v as OperandParameter;
if(ReferenceEquals(p, null))
continue;
if(p.ParameterName != paramName)
continue;
paramNotFound = false;
resultParameters.Add(p);
yyVal = p;
break;
}
if(paramNotFound) {
OperandParameter param = new OperandParameter(paramName);
resultParameters.Add(param);
yyVal = param;
}
}
}
break;
case 28:
#line 148 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 29:
#line 149 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 30:
#line 150 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Multiply ); }
break;
case 31:
#line 151 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Divide ); }
break;
case 32:
#line 152 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Plus ); }
break;
case 33:
#line 153 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Minus ); }
break;
case 34:
#line 154 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Modulo ); }
break;
case 35:
#line 155 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseOr ); }
break;
case 36:
#line 156 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseAnd ); }
break;
case 37:
#line 157 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseXor ); }
break;
case 38:
#line 158 "grammar.y"
{
yyVal = new UnaryOperator( UnaryOperatorType.Minus, (CriteriaOperator)yyVals[0+yyTop] );
try {
if(yyVals[0+yyTop] is OperandValue) {
OperandValue operand = (OperandValue)yyVals[0+yyTop];
if(operand.Value is Int32) {
operand.Value = -(Int32)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int64) {
operand.Value = -(Int64)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Double) {
operand.Value = -(Double)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Decimal) {
operand.Value = -(Decimal)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int16) {
operand.Value = -(Int16)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is SByte) {
operand.Value = -(SByte)operand.Value;
yyVal = operand;
break;
}
}
} catch {}
}
break;
case 39:
#line 191 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.Plus, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 40:
#line 192 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.BitwiseNot, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 41:
#line 193 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Equal); }
break;
case 42:
#line 194 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.NotEqual); }
break;
case 43:
#line 195 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Greater); }
break;
case 44:
#line 196 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Less); }
break;
case 45:
#line 197 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.GreaterOrEqual); }
break;
case 46:
#line 198 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.LessOrEqual); }
break;
case 47:
#line 199 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like); }
break;
case 48:
#line 200 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new BinaryOperator( (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like)); }
break;
case 49:
#line 201 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 50:
#line 202 "grammar.y"
{ yyVal = GroupOperator.And((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 51:
#line 203 "grammar.y"
{ yyVal = GroupOperator.Or((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 52:
#line 204 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 53:
#line 205 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-2+yyTop]); }
break;
case 54:
#line 206 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop])); }
break;
case 55:
#line 207 "grammar.y"
{ yyVal = new InOperator((CriteriaOperator)yyVals[-2+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); }
break;
case 56:
#line 208 "grammar.y"
{ yyVal = new BetweenOperator((CriteriaOperator)yyVals[-6+yyTop], (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 57:
#line 209 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 58:
#line 210 "grammar.y"
{ yyVal = new FunctionOperator(FunctionOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 59:
#line 211 "grammar.y"
{ FunctionOperator fo = new FunctionOperator((FunctionOperatorType)yyVals[-1+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); lexer.CheckFunctionArgumentsCount(fo.OperatorType, fo.Operands.Count); yyVal = fo; }
break;
case 60:
#line 212 "grammar.y"
{ yyVal = null; }
break;
case 61:
#line 216 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 62:
#line 217 "grammar.y"
{ yyVal = new List<CriteriaOperator>(); }
break;
case 63:
#line 221 "grammar.y"
{
List<CriteriaOperator> lst = new List<CriteriaOperator>();
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
case 64:
#line 226 "grammar.y"
{
List<CriteriaOperator> lst = (List<CriteriaOperator>)yyVals[-2+yyTop];
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
#line default
}
yyTop -= yyLen[yyN];
yyState = yyStates[yyTop];
int yyM = yyLhs[yyN];
if(yyState == 0 && yyM == 0) {
yyState = yyFinal;
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if(yyToken == 0)
return yyVal;
goto yyLoop;
}
if(((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
yyState = yyTable[yyN];
else
yyState = yyDgoto[yyM];
goto yyLoop;
}
}
}
object ICriteriaVisitor.Visit(OperandValue theOperand)
{
object value = theOperand.Value;
if (value == null)
return nullString;
TypeCode tc = Type.GetTypeCode(value.GetType());
switch (tc)
{
case TypeCode.DBNull:
case TypeCode.Empty:
return nullString;
case TypeCode.Boolean:
return ((bool)value) ? "1" : "0";
case TypeCode.Char:
return "'" + (char)value + "'";
case TypeCode.DateTime:
DateTime datetimeValue = (DateTime)value;
string dateTimeFormatPattern;
if (datetimeValue.TimeOfDay == TimeSpan.Zero)
{
dateTimeFormatPattern = "yyyyMMdd";
}
else if (datetimeValue.Millisecond == 0)
{
dateTimeFormatPattern = "yyyyMMdd HH:mm:ss";
}
else
{
dateTimeFormatPattern = "yyyyMMdd HH:mm:ss.fff";
}
return "Cast('" + datetimeValue.ToString(dateTimeFormatPattern, CultureInfo.InvariantCulture) + "' as datetime)";
case TypeCode.String:
return AsString(value);
case TypeCode.Decimal:
return FixNonFixedText(((Decimal)value).ToString(CultureInfo.InvariantCulture));
case TypeCode.Double:
return FixNonFixedText(((Double)value).ToString("r", CultureInfo.InvariantCulture));
case TypeCode.Single:
return FixNonFixedText(((Single)value).ToString("r", CultureInfo.InvariantCulture));
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
if (value is Enum)
return Convert.ToInt64(value).ToString();
return value.ToString();
case TypeCode.UInt64:
if (value is Enum)
return Convert.ToUInt64(value).ToString();
return value.ToString();
case TypeCode.Object:
default:
if (value is Guid)
{
return "Cast('" + ((Guid)value).ToString() + "' as Guid)";
}
else if (value is TimeSpan)
{
return FixNonFixedText(((TimeSpan)value).TotalSeconds.ToString("r", CultureInfo.InvariantCulture));
}
else
{
throw new ArgumentException(value.ToString());
}
}
}
// Подготовка параметров для добавления или обновления записи
private void PrepareParameters(bool edit)
{
List<int> setValues = new List<int>(); setValues.Add(0);
int groupIndex = 0, bitIndex = 0;
foreach (DBColumn column in table.Columns)
{
// Ключ
if (column.IsKey && keyProcessed.Contains(column.Name)) continue; // processed key
// Переданное значение
OperandValue value = null;
for (int i = 0; i < Root.Operands.Count; i++)
if (Root.Operands[i] is QueryOperand && ((QueryOperand)Root.Operands[i]).ColumnName == column.Name)
{
value = Root.Parameters[i];
break;
}
// Поле readonly
bool hasValue = !ReferenceEquals(value, null);
if (edit && table.ColumnIsReadOnly(column)) // readonly
if (hasValue) throw new OracleConnectionProviderException(
string.Format("Table '{0}.{1}', column '{2}' is readonly", schemaName, tableName, column.Name));
else continue;
// Значение по умолчанию
if (ReferenceEquals(value, null))
value = new OperandValue(null);
// Обход bug ORA-1460 (см. OracleConnectionProviderEx.CreateParameter)
if (column.ColumnType == DBColumnType.ByteArray && value.Value == null) value.Value = new byte[0];
// Параметр
string parameter = AddParameter(value, column.Name);
if (parametersVars.Length > 0) parametersVars.Append(", ");
parametersVars.Append(parameter);
// Биты редактирования полей
if (edit && !column.IsKey)
{
if (hasValue) setValues[groupIndex] += Convert.ToInt32(Math.Pow(2, bitIndex));
bitIndex++;
if (bitIndex == OracleTemplater.MaxBitsInNumber) { setValues.Add(0); groupIndex++; bitIndex = 0; }
}
}
if (edit)
{
for (groupIndex = 0; groupIndex < setValues.Count; groupIndex++)
{
string parameter = AddParameter(new OperandValue(setValues[groupIndex]),
OracleTemplater.SetValueFlagsParameter + (groupIndex == 0 ? string.Empty : groupIndex.ToString()), false);
if (parametersVars.Length > 0) parametersVars.Append(", ");
parametersVars.Append(parameter);
}
}
}
/// <summary>Добавить параметр</summary>
/// <param name="value">Значение</param>
/// <param name="columnName">Название колонки, если это простой вызов процедуры</param>
/// <param name="formatName">Признак необходимости форматирования названия параметра</param>
/// <returns>Название параметра</returns>
private string AddParameter(OperandValue value, string columnName, bool formatName = true)
{
string name = whereCondition == null && columnName != null ?
(formatName ? formatterSequred.FormatProcedureParameter(columnName) : columnName) :
":p" + commandParamsNames.Count.ToString();
value = identitiesByTag.ConsolidateParameter(value);
commandParamsNames.Add(name);
commandParams.Add(value);
return name;
}
/// <contentfrom cref="ICriteriaVisitor.Visit(OperandValue)"/>
object ICriteriaVisitor.Visit(OperandValue theOperand)
{
return AddParameter(theOperand, null);
}
public override Object Visit(OperandValue operand)
{
if (operand is OperandParameter)
{
if (operand.Value is DateTime)
{
return new CriteriaToStringVisitResult("DateTime'" + ((DateTime)operand.Value).ToString("yyyy-MM-dd HH:mm:ss.fffff") + "'");
}
else
{
return new CriteriaToStringVisitResult(ValueToString(operand.Value));
}
}
else if ((operand.Value != null))
{
if (operand.Value.GetType().IsEnum)
{
return new CriteriaToStringVisitResult(
String.Format("Cast({0} as {1})", ValueToString(System.Convert.ToInt64(operand.Value)), operand.Value.GetType().FullName));
}
else if (operand.Value is Guid)
{
return new CriteriaToStringVisitResult(string.Format(CultureInfo.InvariantCulture, "'{0}'", operand.Value));
}
}
return base.Visit(operand);
}
object ICriteriaVisitor.Visit(OperandValue theOperand)
{
object operandValue = theOperand.Value;
return operandValue;
}
public object Visit(OperandValue theOperand)
{
return BooleanCriteriaStateObject.Value;
}
/// <inheritdoc />
public override string GetNextParameterName(OperandValue parameter)
{
return parent.GetNextParameterName(parameter);
}
private string ProcessOperandValue(OperandValue operandValue)
{
var parameterName = "param" + AggregatedParameters.Count;
var parameterValue = operandValue.Value;
if (parameterValue == null)
{
return "null";
}
AggregatedParameters.Add(parameterName, parameterValue);
return ":" + parameterName;
}
public void ToStringTestNonLegacy()
{
CriteriaOperator opa = new OperandValue() & new OperandValue(true) & 'q' & new DateTime(2006, 12, 02) & "q" & 1m & 1d & 1f & new OperandValue((byte)1) & new OperandValue((sbyte)1) & (short)1 & new OperandValue((ushort)1) & 1 & new OperandValue(1u) & 1L & new OperandValue(1uL) & Guid.Empty & TimeSpan.Zero;
string tostr = opa.ToString();
Assert.AreEqual("? And True And 'q'c And #2006-12-02# And 'q' And 1.0m And 1.0 And 1.0f And 1b And 1sb And 1s And 1us And 1 And 1u And 1L And 1uL And {00000000-0000-0000-0000-000000000000} And #00:00:00#", tostr);
Assert.AreEqual(opa, CriteriaOperator.Parse(tostr));
}
object ICriteriaVisitor.Visit(OperandValue theOperand)
{
object value = theOperand.Value;
if (value == null)
{
return(nullString);
}
TypeCode tc = Type.GetTypeCode(value.GetType());
switch (tc)
{
case TypeCode.DBNull:
case TypeCode.Empty:
return(nullString);
case TypeCode.Boolean:
return(((bool)value) ? "1" : "0");
case TypeCode.Char:
return("'" + (char)value + "'");
case TypeCode.DateTime:
DateTime datetimeValue = (DateTime)value;
string dateTimeFormatPattern;
if (datetimeValue.TimeOfDay == TimeSpan.Zero)
{
dateTimeFormatPattern = "yyyyMMdd";
}
else if (datetimeValue.Millisecond == 0)
{
dateTimeFormatPattern = "yyyyMMdd HH:mm:ss";
}
else
{
dateTimeFormatPattern = "yyyyMMdd HH:mm:ss.fff";
}
return("Cast('" + datetimeValue.ToString(dateTimeFormatPattern, CultureInfo.InvariantCulture) + "' as datetime)");
case TypeCode.String:
return(AsString(value));
case TypeCode.Decimal:
return(FixNonFixedText(((Decimal)value).ToString(CultureInfo.InvariantCulture)));
case TypeCode.Double:
return(FixNonFixedText(((Double)value).ToString("r", CultureInfo.InvariantCulture)));
case TypeCode.Single:
return(FixNonFixedText(((Single)value).ToString("r", CultureInfo.InvariantCulture)));
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
if (value is Enum)
{
return(Convert.ToInt64(value).ToString());
}
return(value.ToString());
case TypeCode.UInt64:
if (value is Enum)
{
return(Convert.ToUInt64(value).ToString());
}
return(value.ToString());
case TypeCode.Object:
default:
if (value is Guid)
{
return("Cast('" + ((Guid)value).ToString() + "' as Guid)");
}
else if (value is TimeSpan)
{
return(FixNonFixedText(((TimeSpan)value).TotalSeconds.ToString("r", CultureInfo.InvariantCulture)));
}
else
{
throw new ArgumentException(value.ToString());
}
}
}
public object Visit(OperandValue theOperand)
{
return evaluatorCore.Visit(theOperand);
}
