# 检查SERVICE变量是否为空
if [ "$SERVICE" = "" ] ; then
  # 如果SERVICE为空，再检查HELP变量是否为"_help"
  if [ "$HELP" = "_help" ] ; then
    # 如果HELP是"_help"，将SERVICE设置为"help"
    SERVICE="help"
  else
    # 如果HELP不是"_help"，将SERVICE设置为"cli"
    SERVICE="cli"
  fi
fi

# 检查SERVICE变量是否为"cli"且USE_BEELINE_FOR_HIVE_CLI变量是否为"true"
if [[ "$SERVICE" == "cli" && "$USE_BEELINE_FOR_HIVE_CLI" == "true" ]] ; then
  # 如果两个条件都满足，将SERVICE设置为"beeline"
  SERVICE="beeline"
fi

以下是给定Hive脚本的中文注释版本：

shell
# 设置THISSERVICE变量为"cli"
THISSERVICE=cli
# 将THISSERVICE添加到SERVICE_LIST环境变量中，后面添加一个空格
export SERVICE_LIST="${SERVICE_LIST}${THISSERVICE} "

# 设置旧版CLI为默认客户端
# 如果USE_DEPRECATED_CLI未设置或不等于false，则使用旧版CLI
if [ -z "$USE_DEPRECATED_CLI" ] || [ "$USE_DEPRECATED_CLI" != "false" ]; then
  USE_DEPRECATED_CLI="true"
fi

# 定义updateCli函数，用于更新CLI配置
updateCli() {
  # 如果USE_DEPRECATED_CLI等于"true"，则配置旧版CLI
  if [ "$USE_DEPRECATED_CLI" == "true" ]; then
    export HADOOP_CLIENT_OPTS=" -Dproc_hivecli $HADOOP_CLIENT_OPTS " # 添加配置选项
    CLASS=org.apache.hadoop.hive.cli.CliDriver # 设置类为旧版CLI驱动
    JAR=hive-cli-*.jar # 设置jar包为旧版CLI的jar包
  else
    # 如果USE_DEPRECATED_CLI不等于"true"，则配置新版CLI(Beeline)
    export HADOOP_CLIENT_OPTS=" -Dproc_beeline $HADOOP_CLIENT_OPTS -Dlog4j.configurationFile=beeline-log4j2.properties" # 添加配置选项
    CLASS=org.apache.hive.beeline.cli.HiveCli # 设置类为新版CLI(Beeline)驱动
    JAR=hive-beeline-*.jar # 设置jar包为新版CLI(Beeline)的jar包
  fi
}

# 定义cli函数，用于执行Hive命令
cli () {
  updateCli # 调用updateCli函数更新配置
  execHiveCmd $CLASS $JAR "$@" # 执行Hive命令
}

# 定义cli_help函数，用于显示Hive命令的帮助信息
cli_help () {
  updateCli # 调用updateCli函数更新配置
  execHiveCmd $CLASS $JAR "--help" # 执行帮助命令
}

 public static void main(String[] args) throws Exception {
    // Hive Cli 启动入口
    int ret = new CliDriver().run(args);
    // 退出虚拟机
    System.exit(ret);
  }

public  int run(String[] args) throws Exception {

    OptionsProcessor oproc = new OptionsProcessor();
    // 解析参数
    if (!oproc.process_stage1(args)) {
      // 解析失败，返回错误码
      return 1;
}
// 省略其它代码
}

// 初始化日志，这里会重新初始化log4j，这样就可以在hive的其他核心类加载之前初始化log4j
boolean logInitFailed = false;
String logInitDetailMessage;
try {
  logInitDetailMessage = LogUtils.initHiveLog4j();
} catch (LogInitializationException e) {
  logInitFailed = true;
  logInitDetailMessage = e.getMessage();
}

// 这里会初始化一些session的配置
CliSessionState ss = new CliSessionState(new HiveConf(SessionState.class));
// 设置一些输入流
ss.in = System.in;
try {
  // 设置输出流
  ss.out = new PrintStream(System.out, true, "UTF-8");
  // 设置信息流
  ss.info = new PrintStream(System.err, true, "UTF-8");
  // 设置错误流
  ss.err = new CachingPrintStream(System.err, true, "UTF-8");
} catch (UnsupportedEncodingException e) {
  // 返回错误码
  return 3;
}

// 解析参数
if (!oproc.process_stage2(ss)) {
  // 参数解析失败，返回错误码
  return 2;
}

// 设置所有通过命令行指定的属性
HiveConf conf = ss.getConf();
for (Map.Entry<Object, Object> item : ss.cmdProperties.entrySet()) {
  conf.set((String) item.getKey(), (String) item.getValue());
  ss.getOverriddenConfigurations().put((String) item.getKey(), 
  (String) item.getValue());
}

// 读取提示配置并替换变量
prompt = conf.getVar(HiveConf.ConfVars.CLIPROMPT);
prompt = new VariableSubstitution(new HiveVariableSource() {
  @Override
  public Map<String, String> getHiveVariable() {
    return SessionState.get().getHiveVariables();
  }
}).substitute(conf, prompt);
prompt2 = spacesForString(prompt);

// 执行cli driver的工作
try {
  return executeDriver(ss, conf, oproc);
} finally {
  ss.resetThreadName();
  ss.close();
}

CliDriver cli = new CliDriver();
cli.setHiveVariables(oproc.getHiveVariables());

// 如果指定了数据库，则使用指定的数据库
cli.processSelectDatabase(ss);

public static void main(String[] args) {
        // 注册钩子函数
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("程序异常终止，执行清理工作");
        }, "Hook模拟线程"));

        while (true) {
            System.out.println(new Date().toString() + ": 逻辑处理");
            try {
                // 休眠10秒
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

CliSessionState ss = (CliSessionState) SessionState.get();
ss.setLastCommand(cmd);

ss.updateThreadName();
// 刷新输出流，这样就不会包含上一条命令的输出
ss.err.flush();
String cmd_trimmed = HiveStringUtils.removeComments(cmd).trim();
// 将 SQL 语句按照空格分割
String[] tokens = tokenizeCmd(cmd_trimmed);
int ret = 0;

int processLocalCmd(String cmd, CommandProcessor proc, CliSessionState ss) {
  boolean escapeCRLF = HiveConf.getBoolVar(conf, 
  HiveConf.ConfVars.HIVE_CLI_PRINT_ESCAPE_CRLF);
  int ret = 0;

  if (proc != null) {
    if (proc instanceof IDriver) {
      IDriver qp = (IDriver) proc;
      PrintStream out = ss.out;
      long start = System.currentTimeMillis();
      if (ss.getIsVerbose()) {
        out.println(cmd);
      }

      ret = qp.run(cmd).getResponseCode();
      if (ret != 0) {
        qp.close();
        return ret;
      }

      // 执行查询，计算时间
      long end = System.currentTimeMillis();
      double timeTaken = (end - start) / 1000.0;

      ArrayList<String> res = new ArrayList<String>();

      printHeader(qp, out);

      // 打印输出结果
      int counter = 0;
      try {
        if (out instanceof FetchConverter) {
          ((FetchConverter) out).fetchStarted();
        }
        while (qp.getResults(res)) {
          for (String r : res) {
                if (escapeCRLF) {
                  r = EscapeCRLFHelper.escapeCRLF(r);
                }
            out.println(r);
          }
          counter += res.size();
          res.clear();
          if (out.checkError()) {
            break;
          }
        }
      } catch (IOException e) {
        console.printError("Failed with exception " 
        + e.getClass().getName() + ":" + e.getMessage(),
            "\n" + org.apache.hadoop.util.StringUtils.stringifyException(e));
        ret = 1;
      }

      qp.close();

      if (out instanceof FetchConverter) {
        ((FetchConverter) out).fetchFinished();
      }

      console.printInfo(
          "Time taken: " + timeTaken + " seconds" 
          + (counter == 0 ? "" : ", Fetched: " + counter + " row(s)"));
    } else {
      String firstToken = tokenizeCmd(cmd.trim())[0];
      String cmd_1 = getFirstCmd(cmd.trim(), firstToken.length());

      if (ss.getIsVerbose()) {
        ss.out.println(firstToken + " " + cmd_1);
      }
      CommandProcessorResponse res = proc.run(cmd_1);
      if (res.getResponseCode() != 0) {
        ss.out
            .println("Query returned non-zero code: " 
            + res.getResponseCode() + ", cause: " + res.getErrorMessage());
      }
      if (res.getConsoleMessages() != null) {
        for (String consoleMsg : res.getConsoleMessages()) {
          console.printInfo(consoleMsg);
        }
      }
      ret = res.getResponseCode();
    }
  }

  return ret;
}