获取所有表、特定表结构：MYSQL、Doris、ORACLE、SQLSERVER、PostgreSQL、Hive、Elasticsearch、FTP、minIO

最新推荐文章于 2024-05-04 13:51:18 发布
最新推荐文章于 2024-05-04 13:51:18 发布
阅读量687 收藏 1
点赞数
文章标签： mysql oracle sqlserver
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57164467/article/details/126936314
版权 
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.1.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>jetty-util</artifactId>
                    <groupId>org.eclipse.jetty</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>3.0.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.eclipse.jetty</groupId>
                    <artifactId>jetty-runner</artifactId>
                </exclusion>
                <exclusion>
                    <artifactId>hive-llap-server</artifactId>
                    <groupId>org.apache.hive</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>log4j-slf4j-impl</artifactId>
                    <groupId>org.apache.logging.log4j</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jetty-util</artifactId>
                    <groupId>org.eclipse.jetty</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>zookeeper</artifactId>
                    <groupId>org.apache.zookeeper</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.9.3</version>
        </dependency>
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.54</version>
        </dependency>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.8.0</version>
        </dependency>
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.3.5</version>
        </dependency>


    @Override
    public List<String> getTableList(Integer id) {
        List<String> stringList = new ArrayList<>();
        SysDatasource dsDetail = getDatasourceDetail(id);
        String datasourceType = dsDetail.getDatasourceType();
        String ip = dsDetail.getHost();
        Integer port = dsDetail.getPort();
        String username = dsDetail.getUsername();
        String password = dsDetail.getPassword();
        String databaseName = dsDetail.getDatabaseName();
        String configParam;
        String url = "";
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        switch (datasourceType) {
            case "MYSQL":
            case "Apache Doris":
                url = "jdbc:mysql://" + ip + ":" + port + "/" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    preparedStatement = connection.prepareStatement("select table_name as tableName from information_schema.tables where table_type = 'BASE TABLE'");
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        stringList.add(resultSet.getString("tableName"));
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "ORACLE":
                url = "jdbc:oracle:thin:@" + ip + ":" + port + "/" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    preparedStatement = connection.prepareStatement("select TABLE_NAME from all_tables WHERE OWNER = '" + username.toUpperCase() + "'");
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        stringList.add(resultSet.getString("TABLE_NAME"));
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "SQLSERVER":
                url = "jdbc:sqlserver://" + ip + ":" + port + ";DatabaseName=" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    preparedStatement = connection.prepareStatement("select name as tableName from sys.objects WHERE type_desc = 'user_table'");
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        stringList.add(resultSet.getString("tableName"));
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "PostgreSQL":
                url = "jdbc:postgresql://" + ip + ":" + port + "/" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    preparedStatement = connection.prepareStatement("select tablename as tableName from pg_tables where tableowner = '" + username + "'");
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        stringList.add(resultSet.getString("tableName"));
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "Apache Hive":
                if (!"".equals(dsDetail.getAddress()) && null != dsDetail.getAddress()) {
                    url = dsDetail.getAddress();
                }
                configParam = dsDetail.getConfigParam();
                if (null != configParam && "1".equals(JSONUtil.parseObj(configParam).getStr("isKerberos"))) {
                    JSONObject cpJson = JSONUtil.parseObj(configParam);
                    String krb5Path = cpJson.getStr("krb5Path");
                    String keytabPath = cpJson.getStr("keytabPath");
                    String principal = cpJson.getStr("principal");
                    String hadoopWinutilsPath = cpJson.getStr("hadoopHomeDir");
                    System.setProperty("java.security.krb5.conf", krb5Path);
                    System.setProperty("hadoop.home.dir", hadoopWinutilsPath);
                    Configuration config = new Configuration();
                    config.set("hadoop.security.authentication", "kerberos");
                    UserGroupInformation.setConfiguration(config);
                    try {
                        UserGroupInformation.loginUserFromKeytab(principal, keytabPath);
                    } catch (IOException e) {
                        LOGGER.error("error", e);
                        break;
                    }
                    url = "".equals(url) ? "jdbc:hive2://" + ip + ":" + port + "/;principal=" + principal : url + "/;principal=" + principal;
                } else {
                    url = "".equals(url) ? "jdbc:hive2://" + ip + ":" + port : url;
                }

                try {
                    connection = DriverManager.getConnection(url);
                    ResultSet tables = connection.getMetaData().getTables(null, "%", "%", new String[]{"TABLE"});
                    while (tables.next()) {
                        stringList.add(tables.getString("table_name"));
                    }
                    tables.close();
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "Elasticsearch":
                //遍历serverAddress，测试所有地址
                List<String> serverAddresses = dsDetail.getServerAddress();
                configParam = dsDetail.getConfigParam();
                for (String serverAddress : serverAddresses) {
                    String[] split;
                    if (serverAddress.contains("//")) {
                        split = serverAddress.split("//")[1].split(":");
                    } else {
                        split = serverAddress.split(":");
                    }
                    ip = split[0];
                    port = Integer.valueOf(split[split.length - 1]);
                    RestHighLevelClient client;
                    if (null != configParam && "1".equals(JSONUtil.parseObj(configParam).getStr("isAuth"))) {
                        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                        Credentials credentials = new UsernamePasswordCredentials(username, password);
                        credentialsProvider.setCredentials(AuthScope.ANY, credentials);
                        client = new RestHighLevelClient(RestClient.builder(new HttpHost(ip, port, "http")).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                            @Override
                            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                                return httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                            }
                        }));
                    } else {
                        client = new RestHighLevelClient(RestClient.builder(new HttpHost(ip, port, "http")).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                            @Override
                            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                                return httpAsyncClientBuilder.setDefaultCredentialsProvider(null);
                            }
                        }));
                    }
                    try {
                        GetIndexResponse getIndexResponse = client.indices().get(new GetIndexRequest("*"), RequestOptions.DEFAULT);
                        String[] indices = getIndexResponse.getIndices();
                        stringList = Arrays.asList(indices);
                    } catch (IOException e) {
                        LOGGER.error("error", e);
                    } finally {
                        try {
                            client.close();
                        } catch (IOException e) {
                            LOGGER.error("error", e);
                        }
                    }
                }
                break;
            case "FTP":
                configParam = dsDetail.getConfigParam();
                if (null != configParam && "1".equals(JSONUtil.parseObj(configParam).getStr("isSftp"))) {
                    Session session = null;
                    Channel channel = null;
                    ChannelSftp sftp = null;
                    port = 22;

                    try {
                        JSch jSch = new JSch();
                        session = jSch.getSession(username, ip, port);
                        session.setPassword(password);
                        session.setConfig("StrictHostKeyChecking", "no");
                        session.connect();
                        channel = session.openChannel("sftp");
                        channel.connect();
                        sftp = (ChannelSftp) channel;
                        stringList = (Vector<String>) sftp.ls("*");
                    } catch (JSchException | SftpException e) {
                        e.printStackTrace();
                    } finally {
                        if (null != sftp) {
                            if (sftp.isConnected()) {
                                sftp.disconnect();
                            }
                        }
                        if (null != channel) {
                            channel.disconnect();
                        }
                        if (null != session) {
                            session.disconnect();
                        }
                    }
                } else {
                    FTPClient ftpClient = new FTPClient();
                    try {
                        ftpClient.connect(ip);
                        ftpClient.login(username, password);
                        if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                            LOGGER.error("连接失败，账号或密码错误！");
                            break;
                        }
                        FTPFile[] ftpFiles = ftpClient.listFiles();
                        for (FTPFile obj : ftpFiles) {
                            stringList.add(obj.getName());
                        }
                    } catch (IOException e) {
                        LOGGER.error("error", e);
                    } finally {
                        try {
                            ftpClient.disconnect();
                        } catch (IOException e) {
                            LOGGER.error("error", e);
                        }
                    }
                }
                break;
            case "minIO":
                String[] split;
                String address = dsDetail.getAddress();
                if (address.contains("//")) {
                    split = address.split("//")[1].split(":");
                } else {
                    split = address.split(":");
                }
                ip = split[0];
                port = Integer.valueOf(split[split.length - 1]);
                url = "http://" + ip + ":" + port;
                MinioClient minioClient = null;
                List<Bucket> buckets = new ArrayList<>();
                try {
                    minioClient = MinioClient.builder()
                            .endpoint(url)
                            .credentials(username, password)
                            .build();
                    buckets = minioClient.listBuckets();
                    for (Bucket bucket : buckets) {
                        stringList.add(bucket.name());
                    }
                } catch (Exception e) {
                    LOGGER.error("error", e);
                    break;
                }
                break;
        }
        return stringList;
    }

    @Override
    public List<TableStruct> getTableStruct(Integer id, String tableName) {
        List<TableStruct> tableStructs = new ArrayList<>();
        SysDatasource dsDetail = getDatasourceDetail(id);
        String datasourceType = dsDetail.getDatasourceType();
        String ip = dsDetail.getHost();
        Integer port = dsDetail.getPort();
        String username = dsDetail.getUsername();
        String password = dsDetail.getPassword();
        String databaseName = dsDetail.getDatabaseName();
        String url = "";
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        switch (datasourceType) {
            case "MYSQL":
            case "Apache Doris":
                url = "jdbc:mysql://" + ip + ":" + port + "/" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    String sql = "select COLUMN_NAME , DATA_TYPE , COLUMN_COMMENT  from information_schema.COLUMNS where TABLE_NAME = '" + tableName + "'";
                    preparedStatement = connection.prepareStatement(sql);
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        TableStruct tableStruct = new TableStruct();
                        tableStruct.setField(resultSet.getString("COLUMN_NAME"));
                        tableStruct.setType(resultSet.getString("DATA_TYPE"));
                        tableStruct.setComments(resultSet.getString("COLUMN_COMMENT"));
                        tableStructs.add(tableStruct);
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "ORACLE":
                url = "jdbc:oracle:thin:@" + ip + ":" + port + "/" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    String sql = "select t.*, c.COMMENTS from user_tab_columns t join user_col_comments c on t.table_name = c.table_name and t.column_name = c.column_name where t.table_name = '" + tableName + "'";
                    preparedStatement = connection.prepareStatement(sql);
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        TableStruct tableStruct = new TableStruct();
                        tableStruct.setField(resultSet.getString("COLUMN_NAME"));
                        tableStruct.setType(resultSet.getString("DATA_TYPE"));
                        tableStruct.setComments(resultSet.getString("COMMENTS"));
                        tableStructs.add(tableStruct);
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "SQLSERVER":
                url = "jdbc:sqlserver://" + ip + ":" + port + ";DatabaseName=" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    String sql = "  select convert(varchar(200), b.name) as column_name, convert(varchar(200), d.DATA_TYPE) as data_type,convert(varchar(200), c.value) as column_desc from sys.columns b " +
                            "left join sys.extended_properties c on c.major_id = b.object_id and c.minor_id = b.column_id " +
                            "inner join INFORMATION_SCHEMA.COLUMNS d on d.column_name = b.name " +
                            "where d.table_name = '" + tableName + "'";
                    preparedStatement = connection.prepareStatement(sql);
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        TableStruct tableStruct = new TableStruct();
                        tableStruct.setField(resultSet.getString("column_name"));
                        tableStruct.setType(resultSet.getString("data_type"));
                        tableStruct.setComments(resultSet.getString("column_desc"));
                        tableStructs.add(tableStruct);
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "SAP HANA":
                //暂不测试
//                url = "jdbc:microsoft:sqlserver://" + ip + ":" + port + "/?" + param;
//                result.put("Response", conn(url, username, password));
//                result.put("address", url);
//                return result;
//                return stringList;
                break;
            case "PostgreSQL":
                url = "jdbc:postgresql://" + ip + ":" + port + "/" + databaseName;
                try {
                    connection = DriverManager.getConnection(url, username, password);
                    String sql = "SELECT A.attname AS field, T.typname AS TYPE, b.description AS COMMENT " +
                            "from pg_class C, pg_attribute A " +
                            "LEFT OUTER JOIN pg_description b ON A.attrelid = b.objoid AND A.attnum = b.objsubid, pg_type T " +
                            "where C.relname = '" + tableName + "'AND A.attnum > 0 AND A.attrelid = C.oid AND A.atttypid = T.oid";
                    preparedStatement = connection.prepareStatement(sql);
                    resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        TableStruct tableStruct = new TableStruct();
                        tableStruct.setField(resultSet.getString("field"));
                        tableStruct.setType(resultSet.getString("TYPE"));
                        tableStruct.setComments(resultSet.getString("COMMENT"));
                        tableStructs.add(tableStruct);
                    }
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (resultSet != null) {
                            resultSet.close();
                        }
                        if (preparedStatement != null) {
                            preparedStatement.close();
                        }
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
            case "Apache Hive":
                if (!"".equals(dsDetail.getAddress()) && null != dsDetail.getAddress()) {
                    url = dsDetail.getAddress();
                }
                String configParam = dsDetail.getConfigParam();
                if (null != configParam && "1".equals(JSONUtil.parseObj(configParam).getStr("isKerberos"))) {
                    JSONObject cpJson = JSONUtil.parseObj(configParam);
                    String krb5Path = cpJson.getStr("krb5Path");
                    String keytabPath = cpJson.getStr("keytabPath");
                    String principal = cpJson.getStr("principal");
                    String hadoopWinutilsPath = cpJson.getStr("hadoopHomeDir");
                    System.setProperty("java.security.krb5.conf", krb5Path);
                    System.setProperty("hadoop.home.dir", hadoopWinutilsPath);
                    Configuration config = new Configuration();
                    config.set("hadoop.security.authentication", "kerberos");
                    UserGroupInformation.setConfiguration(config);
                    try {
                        UserGroupInformation.loginUserFromKeytab(principal, keytabPath);
                    } catch (IOException e) {
                        LOGGER.error("error", e);
                        break;
                    }
                    url = "".equals(url) ? "jdbc:hive2://" + ip + ":" + port + "/;principal=" + principal : url + "/;principal=" + principal;
                } else {
                    url = "".equals(url) ? "jdbc:hive2://" + ip + ":" + port : url;
                }

                try {
                    connection = DriverManager.getConnection(url);
                    ResultSet columns = connection.getMetaData().getColumns(null, "%", tableName, "%");
                    while (columns.next()) {
                        TableStruct tableStruct = new TableStruct();
                        tableStruct.setField(columns.getString("column_name"));
                        tableStruct.setType(columns.getString("type_name"));
                        tableStruct.setComments(columns.getString("remarks"));
                        tableStructs.add(tableStruct);
                    }
                    columns.close();
                } catch (SQLException throwables) {
                    LOGGER.error("error", throwables);
                } finally {
                    try {
                        if (connection != null) {
                            connection.close();
                        }
                    } catch (SQLException throwables) {
                        LOGGER.error("error", throwables);
                    }
                }
                break;
        }
        return tableStructs;
    }
m0_57164467
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
doris批量导出表结构python脚本
12-04
doris批量导出表结构python脚本
测试连接：MYSQL、Doris、ORACLE、SQLSERVER、PostgreSQL、Hive、Elasticsearch、minIO
m0_57164467的博客
09-19 814
【代码】测试连接：MYSQL、Doris、ORACLE、SQLSERVER、PostgreSQL、Hive、Elasticsearch、minIO。
【亲测有效】doris常用的操作命令-掌握库表的情况
06-17 2744
【亲测有效】doris常用的操作命令-掌握库表的情况
Doris通过ODBC连接SQL Server
qq_52967477的博客
12-21 1451
安装目录为/usr/local/unixODBC-2.3.12，安装成功后，unixODBC所需的头文件都被安装到了/usr/local/include下，编译好的库文件安装到了/usr/local/lib 下，与unixODBC相关的可执行文件安装到了/usr/bin下，配置文件放到了/usr/local/etc下。假如查询上述外部表报以下错误，并且/usr/local/freetds/lib/libtdsodbc.so这个文件存在且已授权777。首先创建Resource。然后创建 ODBC 外表。
Doris创建外部表
Denny辉的博客
11-12 1910
drop table if exists mysql_factfinance; CREATE EXTERNAL TABLE mysql_factfinance ( DateKey INT, Amount double, Date date ) ENGINE=ODBC PROPERTIES ( "host" = "192.168.xx.xx", "port" = "3306", "user" = "root", "password" = "root123",
获取所有表
dengyulong的专栏
06-30 146
1.Connection   con=mysql.getConnection()   ;             DatabaseMetaData   md;             md=con.getMetaData()   ;             ResultSet   mrs=md.getTables(null,null,null,new   String[]{ "TABLE "}) ...
获取mysql下所有表
sxf_123456的博客
09-25 2832
select table_name from information_schema.TABLES where TABLE_SCEMA='db_name'; infromation_schema是数据库系统用来保存数据表的总表
获取数据库表结构
Montaque & DotNet
09-06 1632
DataSet ds=new DataSet();System.Data.SqlClient.SqlConnection cnn=new System.Data.SqlClient.SqlConnection("server=(local);database=northwind;trusted_connection=yes") ;cnn.Open();System.Data.SqlClie
怎么获得数据库表结构。
yuanyuan_186的专栏
02-23 489
怎么获得数据库表结构。 1，在注入时初始化这两个模板。 /** * 注入数据源， 该数据源在Spring配置文件中配置 * 在注入时初始化这两个模板 * @param dataSource * Method create author: yanwei * Method create dateTime: 2011-11-2 下
查看doris表结构
weixin_33387378的博客
12-02 406
【代码】查看doris表结构。
Oracle的表结构转成Mysql的表结构
05-18
ORACLE表生成MYSQL建表DDL
mysql虚拟了一个rowid（类似跟oracle的rowid）--SQL语句.sql
02-23
mysql虚拟了一个rowid（类似跟oracle的rowid）--SQL语句
c# oracle转starRocks(doris)建表语句
07-31
目前是oracle转starRocks的建表语句，是doris的衍生，语句差不多，自行调整
孵化器-doris：Apache Doris（正在孵化）
02-28
Doris是用于报告和分析的基于MPP的交互式SQL数据仓库。 它的原始名称是在百度开发的Palo。 捐赠给Apache Software Foundation之后，它更名为Doris。 1.许可证 2.技术 Doris主要集成了Google Mesa和Apache Impala的...
基于springboot+vue+Mysql的幼儿园管理系统
老卓爱爪哇 的博客
05-04 561
本系统采用的数据库是Mysql，使用SpringBoot框架开发，运行环境使用Tomcat服务器，ECLIPSE 是本系统的开发平台。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。 管理员登录成功后进入到系统操作界面，可以对首页、个人中心、用户管理、教师管理、幼儿信息管理、班级信息管理、工作日志管理、会议记录管理、待办事项管理、职工考核管理、请假信息管理、缴费信息管理、幼儿请假管理、儿童体检管理、资源信息管理、原料信
『MySQL 实战 45 讲』20 - 幻读是什么，幻读有什么问题？
最新发布
Gavinjou大笨象的博客
05-04 519
3. 当执行 select * from t where d=5 for update 的时候，6 个记录加上了行锁，还同时加了 7 个间隙锁，这样就确保无法再插入新的记录。
MySQL —— 表的基本操作
学习C++的小陈同学
04-30 390
本篇整理了和表结构相关的各种基本操作（增删查改等等）
MySQL 之 主从复制
我见青山多妩媚,料青山见我应如是
04-28 552
复制是指将主数据库的DDL 和 DML 操作通过二进制日志传到从库服务器中，然后在从库上对这些日志重新执行，从而使得从库和主库的数据保持同步。MySQL支持一台主库同时向多台从库进行复制， 从库同时也可以作为其他从服务器的主库，实现链状复制。
【MySQL】1.安装与配置
2301_79719531的博客
04-28 824
文件的安全性问题。文件不利于数据查询和管理。文件不利于存储海量数据。文件在程序中控制不方便。数据库存储介质：磁盘+内存。为了解决上述问题，专家们设计出更加利于管理数据的软件——数据库，他能更加有效的管理数据。数据库可以提供远程服务，即通过远程连接来使用数据库，因此也称为数据库服务器。
doris 创建hive 外部表 connect hive metastore failed :java lang null
06-13
3. 权限问题：你需要确保Doris对Hive元数据存储有足够的访问权限，以便能够创建外部表。 4. Doris版本不兼容：你需要检查Doris和Hive的版本是否兼容，如果不兼容，可能会导致连接失败。 你需要根据具体情况来排查...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值