示例#1
0
        public override FieldObject Evaluate(RawRecord record)
        {
            string       value1     = f1.Evaluate(record)?.ToValue;
            string       value2     = f2.Evaluate(record)?.ToValue;
            JsonDataType targetType = DataType();

            switch (targetType)
            {
            case JsonDataType.Boolean:
                bool bool_value1, bool_value2;
                if (bool.TryParse(value1, out bool_value1) && bool.TryParse(value2, out bool_value2))
                {
                    switch (binaryType)
                    {
                    case BinaryExpressionType.BitwiseAnd:
                        return(new StringField((bool_value1 ^ bool_value2).ToString(), JsonDataType.Boolean));

                    case BinaryExpressionType.BitwiseOr:
                        return(new StringField((bool_value1 | bool_value2).ToString(), JsonDataType.Boolean));

                    case BinaryExpressionType.BitwiseXor:
                        return(new StringField((bool_value1 ^ bool_value2).ToString(), JsonDataType.Boolean));

                    default:
                        throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type \"boolean\".");
                    }
                }
                else
                {
                    throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"boolean\"",
                                                                      value1, value2));
                }

            case JsonDataType.Bytes:
                switch (binaryType)
                {
                case BinaryExpressionType.Add:
                    return(new StringField(value1 + value2.Substring(2), JsonDataType.Bytes));

                default:
                    throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type \"bytes\".");
                }

            case JsonDataType.Int:
                int int_value1, int_value2;
                if (int.TryParse(value1, out int_value1) && int.TryParse(value2, out int_value2))
                {
                    switch (binaryType)
                    {
                    case BinaryExpressionType.Add:
                        return(new StringField((int_value1 + int_value2).ToString(), JsonDataType.Int));

                    case BinaryExpressionType.BitwiseAnd:
                        return(new StringField((int_value1 & int_value2).ToString(), JsonDataType.Int));

                    case BinaryExpressionType.BitwiseOr:
                        return(new StringField((int_value1 | int_value2).ToString(), JsonDataType.Int));

                    case BinaryExpressionType.BitwiseXor:
                        return(new StringField((int_value1 ^ int_value2).ToString(), JsonDataType.Int));

                    case BinaryExpressionType.Divide:
                        return(new StringField((int_value1 / int_value2).ToString(), JsonDataType.Int));

                    case BinaryExpressionType.Modulo:
                        return(new StringField((int_value1 % int_value2).ToString(), JsonDataType.Int));

                    case BinaryExpressionType.Multiply:
                        return(new StringField((int_value1 * int_value2).ToString(), JsonDataType.Int));

                    case BinaryExpressionType.Subtract:
                        return(new StringField((int_value1 - int_value2).ToString(), JsonDataType.Int));

                    default:
                        return(new StringField(""));
                    }
                }
                else
                {
                    throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"int\"",
                                                                      value1, value2));
                }

            case JsonDataType.Long:
                long long_value1, long_value2;
                if (long.TryParse(value1, out long_value1) && long.TryParse(value2, out long_value2))
                {
                    switch (binaryType)
                    {
                    case BinaryExpressionType.Add:
                        return(new StringField((long_value1 + long_value2).ToString(), JsonDataType.Long));

                    case BinaryExpressionType.BitwiseAnd:
                        return(new StringField((long_value1 & long_value2).ToString(), JsonDataType.Long));

                    case BinaryExpressionType.BitwiseOr:
                        return(new StringField((long_value1 | long_value2).ToString(), JsonDataType.Long));

                    case BinaryExpressionType.BitwiseXor:
                        return(new StringField((long_value1 ^ long_value2).ToString(), JsonDataType.Long));

                    case BinaryExpressionType.Divide:
                        return(new StringField((long_value1 / long_value2).ToString(), JsonDataType.Long));

                    case BinaryExpressionType.Modulo:
                        return(new StringField((long_value1 % long_value2).ToString(), JsonDataType.Long));

                    case BinaryExpressionType.Multiply:
                        return(new StringField((long_value1 * long_value2).ToString(), JsonDataType.Long));

                    case BinaryExpressionType.Subtract:
                        return(new StringField((long_value1 - long_value2).ToString(), JsonDataType.Long));

                    default:
                        return(new StringField(""));
                    }
                }
                else
                {
                    throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"long\"",
                                                                      value1, value2));
                }

            case JsonDataType.Double:
                double double_value1, double_value2;
                if (double.TryParse(value1, out double_value1) && double.TryParse(value2, out double_value2))
                {
                    switch (binaryType)
                    {
                    case BinaryExpressionType.Add:
                        return(new StringField((double_value1 + double_value2).ToString(), JsonDataType.Double));

                    case BinaryExpressionType.Divide:
                        return(new StringField((double_value1 / double_value2).ToString(), JsonDataType.Double));

                    case BinaryExpressionType.Modulo:
                        return(new StringField((double_value1 % double_value2).ToString(), JsonDataType.Double));

                    case BinaryExpressionType.Multiply:
                        return(new StringField((double_value1 * double_value2).ToString(), JsonDataType.Double));

                    case BinaryExpressionType.Subtract:
                        return(new StringField((double_value1 - double_value2).ToString(), JsonDataType.Double));

                    default:
                        throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type 'double'.");
                    }
                }
                else
                {
                    throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"double\"",
                                                                      value1, value2));
                }

            case JsonDataType.Float:
                float float_value1, float_value2;
                if (float.TryParse(value1, out float_value1) && float.TryParse(value2, out float_value2))
                {
                    switch (binaryType)
                    {
                    case BinaryExpressionType.Add:
                        return(new StringField((float_value1 + float_value2).ToString(), JsonDataType.Float));

                    case BinaryExpressionType.Divide:
                        return(new StringField((float_value1 / float_value2).ToString(), JsonDataType.Float));

                    case BinaryExpressionType.Modulo:
                        return(new StringField((float_value1 % float_value2).ToString(), JsonDataType.Float));

                    case BinaryExpressionType.Multiply:
                        return(new StringField((float_value1 * float_value2).ToString(), JsonDataType.Float));

                    case BinaryExpressionType.Subtract:
                        return(new StringField((float_value1 - float_value2).ToString(), JsonDataType.Float));

                    default:
                        throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type 'float'.");
                    }
                }
                else
                {
                    throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"float\"",
                                                                      value1, value2));
                }

            case JsonDataType.String:
                switch (binaryType)
                {
                case BinaryExpressionType.Add:
                    return(new StringField(value1 + value2));

                default:
                    throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type \"string\".");
                }

            case JsonDataType.Date:
                throw new NotImplementedException();

            case JsonDataType.Null:
                return(null);

            default:
                throw new QueryCompilationException("Unsupported data type.");
            }
        }