示例#1
0
        public override string ToSql(ExpressionSqlBuilder builder)
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(" CASE ");
            if (CaseArg != null)
            {
                sb.Append(CaseArg.ToSql(builder)).Append(" ");
            }
            foreach (var wt in ListWhenThen)
            {
                sb.Append(wt.ToSql(builder)).Append(" ");
            }
            if (Else != null)
            {
                sb.Append(" ELSE ").Append(Else.ToSql(builder)).Append(" ");
            }
            sb.Append("END ");
            return(sb.ToString());
        }
示例#2
0
 protected override bool CanCalcOnline()
 {
     if (CaseArg != null && !CaseArg.OnlyOnline())
     {
         return(false);
     }
     if (Else != null && !Else.OnlyOnline())
     {
         return(false);
     }
     foreach (var wt in ListWhenThen)
     {
         if (wt.Then != null && !wt.Then.OnlyOnline())
         {
             return(false);
         }
         if (wt.When != null && !wt.When.OnlyOnline())
         {
             return(false);
         }
     }
     return(true);
 }
示例#3
0
 public bool CaseAsTime(WhenThen wt, object data)
 {
     return(CaseArg.GetTimeResultOut(data) == wt.When.GetTimeResultOut(data));
 }
示例#4
0
 public bool CaseAsBool(WhenThen wt, object data)
 {
     return(CaseArg.GetBoolResultOut(data) == wt.When.GetBoolResultOut(data));
 }
示例#5
0
 public bool CaseAsFloat(WhenThen wt, object data)
 {
     return(CaseArg.GetFloatResultOut(data) == wt.When.GetFloatResultOut(data));
 }
示例#6
0
        public override void Prepare()
        {
            if (CaseArg != null)
            {
                CaseArg.Prepare();
            }
            foreach (var wt in ListWhenThen)
            {
                wt.Prepare();
            }
            if (Else != null)
            {
                Else.Prepare();
            }
            base.Prepare();
            if (ListWhenThen.Count == 0)
            {
                throw new Exception("Not found \"When\"");
            }
            SimpleTypes st1 = ListWhenThen[0].Then.GetResultType();

            foreach (var wt in ListWhenThen)
            {
                SimpleTypes st2 = wt.Then.GetResultType();
                if (st1 != st2)
                {
                    if (st1.IsNumber() && st2.IsNumber())
                    {
                        st1 = SimpleTypes.Float;
                    }
                    else
                    {
                        this.TypesException();
                    }
                }
            }
            //Case.GetObjectResultOut()
            SetResultType(st1);
            switch (st1)
            {
            case SimpleTypes.Date:
            case SimpleTypes.DateTime:
                GetDateTimeResultOut = AsDateTime;
                break;

            case SimpleTypes.Time:
                GetTimeResultOut = AsTime;
                break;

            case SimpleTypes.Float:
                GetFloatResultOut = AsFloat;
                break;

            case SimpleTypes.Boolean:
                GetBoolResultOut = AsBool;
                break;

            case SimpleTypes.Integer:
                GetIntResultOut = AsInt;
                break;

            case SimpleTypes.String:
                GetStrResultOut = AsStr;
                break;
            }
            if (CaseArg != null)
            {
                var st2 = CaseArg.GetResultType();
                switch (st2)
                {
                case SimpleTypes.Date:
                case SimpleTypes.DateTime:
                    CaseCompare = CaseAsDateTime;
                    break;

                case SimpleTypes.Float:
                    CaseCompare = CaseAsFloat;
                    break;

                case SimpleTypes.Boolean:
                    CaseCompare = CaseAsBool;
                    break;

                case SimpleTypes.Integer:
                    CaseCompare = CaseAsInt;
                    break;

                case SimpleTypes.String:
                    CaseCompare = CaseAsStr;
                    break;

                case SimpleTypes.Time:
                    CaseCompare = CaseAsTime;
                    break;

                default:
                    throw new Exception("Can not compare arguments");
                }
            }
        }