在Oracle和MySQL中，您可以使用SQL查询来获取所有表信息和字段信息。以下是针对这两种数据库的相应查询：

Oracle:

SELECT table_name FROM user_tables; -- 获取所有用户表
 
SELECT column_name, data_type, data_length
FROM user_tab_columns
WHERE table_name = 'YOUR_TABLE_NAME'; -- 获取指定表的所有字段信息

MySQL:

SHOW TABLES; -- 获取数据库中的所有表
 
SELECT column_name, data_type, character_maximum_length
FROM information_schema.columns
WHERE table_schema = 'your_database_name' AND table_name = 'your_table_name'; -- 获取指定表的所有字段信息

请将 'YOUR_TABLE_NAME' 和 'your_database_name' 替换为您实际的表名和数据库名。在MySQL中，table_schema 对应数据库名的概念。在Oracle中，user_前缀表示只查询当前用户的表和视图。

由于您的问题是关于MySQL DBA运维实战，我们可以提供一些实际的运维操作示例。以下是一些常见的MySQL运维操作：

1. 数据库备份：

mysqldump -u 用户名 -p密码 数据库名 > 备份文件.sql

2. 数据库恢复：

mysql -u 用户名 -p密码 数据库名 < 备份文件.sql

3. 查看数据库大小：

SELECT table_schema AS "DB Name", 
ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS "Size (MB)"
FROM information_schema.TABLES 
GROUP BY table_schema;

4. 优化表：

OPTIMIZE TABLE 表名;

5. 检查表：

CHECK TABLE 表名;

6. 查看正在运行的进程：

SHOW PROCESSLIST;

7. 杀掉某个进程：

KILL 进程ID;

8. 设置全局查询日志：

SET GLOBAL general_log = 'ON';

9. 查看系统变量：

SHOW VARIABLES LIKE '变量名';

10. 设置系统变量：

SET GLOBAL 变量名 = 值;

这些操作是MySQL运维中常见的，可以根据实际需要进行相应的操作。在实际操作中，还需要考虑权限、性能影响、备份策略等多方面因素。

由于这个项目涉及的内容较多且涉及到个人隐私和商业利益，我无法提供完整的代码。但我可以提供一个简化的框架代码示例，说明如何实现一个基本的用户模块。

// UserController.java (Spring MVC Controller)
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller
@RequestMapping("/user")
public class UserController {
 
    // 假设这里注入了UserService
    private UserService userService;
 
    @RequestMapping(value = "/register", method = RequestMethod.POST)
    public @ResponseBody String registerUser(@RequestParam String username,
                                             @RequestParam String password) {
        // 调用服务层的方法来注册用户
        boolean success = userService.register(username, password);
        return success ? "注册成功" : "注册失败";
    }
 
    // ... 其他用户操作，如登录、查找用户信息等
}
 
// UserService.java (Spring Service)
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class UserService {
 
    @Autowired
    private UserRepository userRepository; // 假设这是Spring Data JPA的Repository
 
    public boolean register(String username, String password) {
        // 在这里可以添加更多的验证逻辑
        User user = new User();
        user.setUsername(username);
        user.setPassword(password); // 这里应当处理密码的安全存储，例如使用BCrypt
        userRepository.save(user);
        return true;
    }
 
    // ... 其他用户操作方法
}
 
// User.java (实体类)
public class User {
    private Long id;
    private String username;
    private String password;
 
    // 省略getter和setter方法
}

这个简化的框架代码展示了如何在一个Java Web项目中使用Spring框架来创建一个用户注册功能。在实际的项目中，你需要配置数据库连接、事务管理、安全性等方面的细节。这个例子只是展示了如何在后端框架中定义一个简单的用户注册功能，并未包含完整的系统实现。

以下是一个基于Keepalived和Nginx实现双机热备和负载均衡的高可用性部署示例：

1. 安装Keepalived和Nginx。
2. 配置Keepalived，确保配置文件指定了虚拟IP（VIP）和优先级。
3. 配置Nginx，使用upstream模块设置Tomcat服务器的负载均衡。
4. 配置MySQL，可以使用MHA（Master High Availability）来保证数据的一致性和高可用性。

Keepalived配置示例：

global_defs {
   router_id LVS_DEVEL
}
 
vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
2.168.1.100
    }
}

Nginx配置示例（在nginx.conf中）：

http {
    upstream tomcat_server {
        server tomcat1.example.com:8080 weight=1;
        server tomcat2.example.com:8080 weight=1;
    }
 
    server {
        listen 80;
 
        location / {
            proxy_pass http://tomcat_server;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

在这个示例中，Keepalived确保了虚拟IP在主服务器和备服务器之间平衡。Nginx通过upstream模块实现了Tomcat服务器的负载均衡，并且可以通过配置来处理来自客户端的HTTP请求。

请注意，这只是一个高级别的部署示例，实际部署时需要考虑更多的细节，如Tomcat服务器的配置、MySQL的高可用设置等。

该系统主要涉及到的功能有：用户登录、用户管理、工作人员信息管理、健康信息管理、外出申请与跟踪管理、系统管理等。

1. 用户登录：用户登录系统进行操作。
2. 用户管理：管理员可以管理系统用户信息。
3. 工作人员信息管理：管理员可以管理工作人员的基本信息。
4. 健康信息管理：工作人员可以填写每日的健康信息。
5. 外出申请与跟踪管理：工作人员可以申请外出并跟踪外出过程中的健康信息。
6. 系统管理：管理员可以管理系统的基本信息。

以下是部分代码实例：

// 用户登录接口
@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody User user) {
    // 登录逻辑
}
 
// 工作人员信息管理接口
@PostMapping("/worker/save")
public ResponseEntity<?> saveWorker(@RequestBody Worker worker) {
    // 保存工作人员信息逻辑
}
 
// 健康信息管理接口
@PostMapping("/health/save")
public ResponseEntity<?> saveHealth(@RequestBody Health health) {
    // 保存健康信息逻辑
}
 
// 外出申请与跟踪管理接口
@PostMapping("/outbound/apply")
public ResponseEntity<?> applyOutbound(@RequestBody Outbound outbound) {
    // 外出申请逻辑
}
 
// 系统管理接口
@PostMapping("/system/setting")
public ResponseEntity<?> saveSystemSetting(@RequestBody SystemSetting systemSetting) {
    // 保存系统设置逻辑
}

注意：以上代码仅为示例，具体实现需要根据实际需求进行详细设计。

以下是一个基本的MySQL安装与配置的步骤，适用于大多数操作系统。

1. 下载MySQL Server：

   访问MySQL官方网站下载最新版的MySQL Server安装包。

2. 安装MySQL Server：

   • Windows: 双击下载的.msi文件并遵循安装向导。
   • macOS: 打开下载的.dmg文件，然后将MySQL添加到应用程序文件夹。
   • Linux: 使用包管理器（如apt for Ubuntu或Debian，yum for CentOS，zypper for openSUSE）安装MySQL。

   示例（以Ubuntu为例）:

   
   
   
   sudo apt update
   sudo apt install mysql-server

3. 配置MySQL Server：

   • Windows: 安装完成后，MySQL服务通常会自动启动。你可以通过服务管理器或命令行查看和管理服务。
   • macOS/Linux: 启动MySQL服务：

   
   
   
   sudo systemctl start mysql

   开机自启MySQL服务：

   
   
   
   sudo systemctl enable mysql

4. 安全设置（仅首次安装时需要）：

   运行安全脚本来设置root密码和调整安全选项：

   
   
   
   sudo mysql_secure_installation

5. 登录MySQL：

   
   
   
   mysql -u root -p

   输入你之前设置的密码登录。

6. 创建数据库和用户（可选）：

   在MySQL提示符下，你可以创建新的数据库和用户：

   
   
   
   CREATE DATABASE mydatabase;
   CREATE USER 'myuser'@'localhost' IDENTIFIED BY 'mypassword';
   GRANT ALL PRIVILEGES ON mydatabase.* TO 'myuser'@'localhost';
   FLUSH PRIVILEGES;

以上步骤涵盖了基本的MySQL安装与配置过程。根据你的操作系统和具体需求，可能还需要进行额外的配置。

以下是一个简化的Dockerfile示例，用于构建包含SSH、Systemd、nginx、Tomcat、MySQL的镜像。请注意，这个示例仅用于教学目的，实际上在Docker中运行MySQL、Tomcat等可能会有安全和性能的考量，通常建议使用专门的Docker镜像库，例如官方MySQL和Tomcat镜像。

FROM ubuntu:20.04
 
# 安装SSH服务，以便可以远程访问容器
RUN apt-get update && apt-get install -y openssh-server
RUN mkdir /var/run/sshd
RUN echo 'root:yourpassword' | chpasswd
 
# 安装并配置systemd
RUN dpkg-divert --local --rename --add /bin/sh
RUN ln -sf /bin/bash /bin/sh
RUN apt-get update && apt-get install -y systemd
 
# 安装nginx
RUN apt-get update && apt-get install -y nginx
 
# 安装Tomcat
RUN apt-get update && apt-get install -y openjdk-11-jdk
RUN mkdir /opt/tomcat
ADD tomcat.tar.gz /opt/tomcat
RUN chmod +x /opt/tomcat/bin/*.sh
ENV CATALINA_HOME /opt/tomcat
ENV PATH $CATALINA_HOME/bin:$PATH
 
# 安装MySQL
RUN apt-get update && apt-get install -y mysql-server
RUN mysql_install_db
RUN echo 'root:yourpassword' | chpasswd
RUN sed -i 's/bind-address\ \=\ 127.0.0.1/bind-address\ \=\ 0.0.0.0/' /etc/mysql/mysql.conf.d/mysqld.cnf
 
# 启动SSH服务和nginx
CMD ["/usr/sbin/sshd", "-D"]
CMD ["nginx", "-g", "daemon off;"]
 
# 启动systemd
CMD ["systemd"]

请注意，这个Dockerfile中的某些命令可能需要根据实际情况进行调整，例如更改SSH密码、配置MySQL等。在实际部署中，应当考虑安全性和性能，并使用专业的Docker镜像来运行数据库和应用服务器。

在Apache NiFi中，要实现PostgreSQL和MySQL数据库的同步，并指定库、指定多表进行全量同步，可以使用NiFi的处理器如ExecuteSQL来执行SQL语句，并使用PutMysql或PutDatabaseRecord等处理器将数据同步到MySQL。

以下是一个基本的流程示例：

1. 使用ExecuteSQL处理器从PostgreSQL读取数据。
2. 使用ConvertRecord处理器进行数据类型转换，以适应MySQL的数据格式。
3. 使用PutMysql或PutDatabaseRecord处理器将数据写入MySQL。

确保在PostgreSQL和MySQL中配置了正确的HBA（host-based authentication），以允许NiFi服务器进行连接。

以下是一个简化的NiFi模板，展示了如何从PostgreSQL读取数据并同步到MySQL：

<?xml version="1.0" encoding="UTF-8"?>
<template>
  <processors>
    <id>1</id>
    <parentGroupId>2</parentGroupId>
    <position>
      <x>0</x>
      <y>0</y>
    </position>
    <bundle>
      <group>org.apache.nifi</group>
      <artifact>nifi-standard-processors</artifact>
      <version>1.21.0</version>
    </bundle>
    <type>org.apache.nifi.processors.standard.ExecuteSQL</type>
    <config>
      <!-- 配置PostgreSQL连接 -->
      <property>
        <name>Database Connection Pool Name</name>
        <value>PostgreSQL Connection Pool</value>
      </property>
      <property>
        <name>SQL Script</name>
        <value>SELECT * FROM your_table1; SELECT * FROM your_table2;</value>
      </property>
      <!-- 其他配置... -->
    </config>
  </processors>
  <processors>
    <id>2</id>
    <parentGroupId>3</parentGroupId>
    <position>
      <x>0</x>
      <y>0</y>
    </position>
    <bundle>
      <group>org.apache.nifi</group>
      <artifact>nifi-standard-processors</artifact>
      <version>1.21.0</version>
    </bundle>
    <type>org.apache.nifi.processors.standard.PutDatabaseRecord</type>
    <config>
      <!-- 配置MySQL连接 -->
      <property>
        <name>Controller Service</name>
        <value>Database Connection Pool for MySQL</value>
      </property>
      <property>
        <name>Table Name</name>
        <value>your_table1</value>
      </property>
      <!-- 其他配置... -->
    </config>
  </processors>
  <connections>
    <id>1</id>
    <source>
      <id>1</id>
      <groupId>2</groupId>
    </source>
    <destination>
      <id>2</id>
      <groupId>3</groupId>
    </destination>
  </connections>
  <controllerServices>
    <id>1</id>
    <bundle>
      <group>org.apache.nifi</group>
      <artifact>nifi-database-bundle</artifact>
      <version>1.21.0</version>
    </bundle>
    <type>org.apac

在CentOS 7上安装Docker，并学习常用的Docker命令，接着使用Docker安装常见的组件，如Tomcat、MySQL和Redis。

1. 安装Docker:

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install -y docker-ce docker-ce-cli containerd.io
sudo systemctl start docker
sudo systemctl enable docker

2. Docker常用命令:

# 启动Docker
sudo systemctl start docker
 
# 停止Docker
sudo systemctl stop docker
 
# 重启Docker
sudo systemctl restart docker
 
# 查看Docker状态
sudo systemctl status docker
 
# 查看Docker版本
docker --version
 
# 查看所有容器
docker ps -a
 
# 查看运行中的容器
docker ps
 
# 拉取镜像
docker pull 镜像名称
 
# 创建并启动容器
docker run -d -p 主机端口:容器端口 --name 容器名称 镜像名称
 
# 停止容器
docker stop 容器名称或ID
 
# 删除容器
docker rm 容器名称或ID
 
# 删除镜像
docker rmi 镜像名称或ID

3. 使用Docker安装Tomcat:

docker run -d -p 8080:8080 --name my-tomcat tomcat:9.0

4. 使用Docker安装MySQL:

docker run -d -p 3306:3306 --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw mysql:5.7

5. 使用Docker安装Redis:

docker run -d -p 6379:6379 --name my-redis redis:5.0

以上命令需要在具备sudo权限的CentOS 7系统上执行。这些命令展示了如何安装Docker，启动和使用它来运行Tomcat、MySQL和Redis等常见的Web服务。

由于您的问题没有提供具体的代码或SQL查询，我无法提供针对特定查询的解决方案。但我可以提供一个简单的SQL查询示例，用于查询MySQL数据库中的用户信息。

SELECT user, host FROM mysql.user;

这条SQL查询将会列出MySQL数据库中所有用户的用户名和它们的主机地址。这是一个很基础的查询，用于获取数据库用户的概览信息。在实际运维中，DBA可能需要查询更多的信息，比如用户的权限、分配的数据库、密码过期策略等。