public virtual SqlExpression? Translate()

in EFCore/src/Query/Internal/MySQLDateTimeMethodTranslator.cs [78:162]
78 lines of code
16 McCabe index (conditional complexity)

    public virtual SqlExpression? Translate(SqlExpression? instance, MethodInfo method, IReadOnlyList<SqlExpression> arguments, IDiagnosticsLogger<DbLoggerCategory.Query> logger)
    {
      if (_methodInfoDatePartMapping.TryGetValue(method, out var datePart))
      {
        return !datePart.Equals("year")
          && !datePart.Equals("month")
          && arguments[0] is SqlConstantExpression sqlConstant
          && ((double)sqlConstant.Value! >= int.MaxValue
          || (double)sqlConstant.Value <= int.MinValue)
          ? null
          : _sqlExpressionFactory.Function(
            "DATE_ADD",
            new[]
            {
        instance!,
        _sqlExpressionFactory.ComplexFunctionArgument(new SqlExpression[]
        {
          _sqlExpressionFactory.Fragment("INTERVAL"),
          _sqlExpressionFactory.Convert(arguments[0], typeof(int)),
          _sqlExpressionFactory.Fragment(datePart)
        },
        " ",
        typeof(string))
            },
            nullable: true,
#if !NET9_0
            argumentsPropagateNullability: TrueArrays[1],
#else
            argumentsPropagateNullability: new[] { true, false },
#endif
            instance!.Type,
            instance.TypeMapping);
      }

      if (method.DeclaringType == typeof(TimeOnly))
      {
        if (method == _timeOnlyAddTimeSpanMethod)
        {
          return _sqlExpressionFactory.Add(instance!, arguments[0]);
        }

        if (method == _timeOnlyIsBetweenMethod)
        {
          return _sqlExpressionFactory.And(
              _sqlExpressionFactory.GreaterThanOrEqual(instance!, arguments[0]),
              _sqlExpressionFactory.LessThan(instance!, arguments[1]));
        }
      }

      if (method.DeclaringType == typeof(DateOnly))
      {
        if (method == _dateOnlyFromDateTimeMethod)
        {
          return _sqlExpressionFactory.NullableFunction(
            "DATE",
            new[] { arguments[0] },
            method.ReturnType);
        }

        if (method == _dateOnlyToDateTimeMethod)
        {
          var convertExpression = _sqlExpressionFactory.Convert(
            instance!,
            method.ReturnType);

          if (arguments[0] is SqlConstantExpression sqlConstantExpression &&
            sqlConstantExpression.Value is TimeOnly timeOnly &&
            timeOnly == default)
          {
            return convertExpression;
          }

          return _sqlExpressionFactory.NullableFunction(
            "ADDTIME",
            new[]
            {
              convertExpression,
              arguments[0]
            },
            method.ReturnType);
        }
      }

      return null;
    }