ORACLE数据库-执行SQL的接口

最新推荐文章于 2024-07-26 14:20:58 发布
最新推荐文章于 2024-07-26 14:20:58 发布
阅读量343 收藏
点赞数
分类专栏： JAVA 数据库 文章标签： 数据库 oracle sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Win_Dan/article/details/129355228
版权

依赖

<!-- druid数据库连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.22</version>
</dependency>

<!-- 数据库操作工具类依赖 -->
<dependency>
    <groupId>com.jfinal</groupId>
    <artifactId>activerecord</artifactId>
    <version>4.9.16</version>
</dependency>

配置类

package cn.window.debt.infrastructure.config;

import cn.hutool.core.util.StrUtil;
import cn.window.boot.base.common.util.Func;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

import java.util.List;
import java.util.stream.Collectors;

/**
 * backdoor配置
 */
@Slf4j
@Order
@Configuration("backdoorConfig")
@Data
@RefreshScope
public class BackdoorConfig implements InitializingBean {
	// 是否启用后门
    private boolean enable;
	// 是否启用表名检查
    private boolean enableTableCheck;
	// 数据库url
    private String debtDbUrl;
	// 数据库用户
    private String debtDbUser;
	// 数据库密码
    private String debtDbPwd;
	// 数据库可操作性表名
    private String workTables;

    private List<String> workTableList;

    @Value("${debt.backdoor.enable:false}")
    public void setEnable(boolean enable) {
        this.enable = enable;
    }

    @Value("${debt.backdoor.enableTableCheck:true}")
    public void setEnableTableCheck(boolean enableTableCheck) {
        this.enableTableCheck = enableTableCheck;
    }

    @Value("${debt.backdoor.debtDbUrl:}")
    public void setDebtDbUrl(String debtDbUrl) {
        this.debtDbUrl = debtDbUrl;
    }

    @Value("${debt.backdoor.debtDbUser:}")
    public void setDebtDbUser(String debtDbUser) {
        this.debtDbUser = debtDbUser;
    }

    @Value("${debt.backdoor.debtDbPwd:}")
    public void setDebtDbPwd(String debtDbPwd) {
        this.debtDbPwd = debtDbPwd;
    }

    @Value("${debt.backdoor.workTables:}")
    public void setWorkTable(String workTables) {
        this.workTables = workTables;
    }

    @Override
    public void afterPropertiesSet() {
        log.info("backdoor配置, enable -> {}, enableTableCheck -> {}, debtDbUrl -> {}, debtDbUser -> {}, debtDbPwd -> {}, workTables -> {}",
                enable, enableTableCheck, debtDbUrl, debtDbUser, debtDbPwd, workTables);
        if (StrUtil.isNotBlank(workTables)) {
            this.workTableList = Func.toStrList(workTables).stream().map(tableName -> tableName.trim().toUpperCase()).collect(Collectors.toList());
        }
    }
}

执行SQL的工作类

package cn.window.debt.interfaces.back.actuator;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLStatement;
import com.alibaba.druid.sql.dialect.oracle.visitor.OracleSchemaStatVisitor;
import com.alibaba.druid.stat.TableStat;
import com.alibaba.druid.util.JdbcConstants;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.jfinal.kit.StrKit;
import com.jfinal.plugin.activerecord.ActiveRecordPlugin;
import com.jfinal.plugin.activerecord.CaseInsensitiveContainerFactory;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.Record;
import com.jfinal.plugin.activerecord.dialect.OracleDialect;
import com.jfinal.plugin.druid.DruidPlugin;
import cn.window.boot.base.api.enums.BaseCode;
import cn.window.boot.base.api.exception.BizException;
import cn.window.debt.infrastructure.config.BackdoorConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.io.*;
import java.util.*;

@Slf4j
@Component
public class SqlActuator {

    @Autowired
    private BackdoorConfig backdoorConfig;

    private DruidPlugin debtDruidPlugin;
    private ActiveRecordPlugin debtArp;

    @Transactional(rollbackFor = Exception.class)
    public Object execSql(File sqlFile) {
        if (debtArp == null) {
            debtDruidPlugin = new DruidPlugin(backdoorConfig.getDebtDbUrl(), backdoorConfig.getDebtDbUser(),
                    backdoorConfig.getDebtDbPwd(), "oracle.jdbc.driver.OracleDriver");
            debtArp = new ActiveRecordPlugin("sqlActuator", debtDruidPlugin);
            debtArp.setDialect(new OracleDialect());
            debtArp.setContainerFactory(new CaseInsensitiveContainerFactory());
            debtDruidPlugin.start();
            debtArp.start();
        }
        String sqls = readFile(sqlFile);
        if (StrUtil.isBlank(sqls)) {
            throw new BizException(BaseCode.ERROR, "sql不能为空");
        }
        String[] sqlArr = sqls.split(";");
        if (backdoorConfig.isEnableTableCheck()) {
            checkTable(sqlArr);
        }
        Map<String, Object> resultMap = new LinkedHashMap<String, Object>();
        s:
        for (int i = 0; i < sqlArr.length; i++) {
            String sql = sqlArr[i];
            if (StrKit.notBlank(sql.trim())) {
                if (sql.indexOf("--") == 0) {
                    continue s;
                }
                String[] wordArr = sql.split(" ");
                for (String word : wordArr) {
                    word = word.toUpperCase();
                    if ("SELECT".equals(word)) {
                        List<Record> findList = Db.use("sqlActuator").find(sql);
                        List<Map<String, Object>> resultList = new ArrayList<Map<String, Object>>();
                        for (Record record : findList) {
                            resultList.add(record.getColumns());
                        }
//                        log.info("SQL [{}] select result [{}]", sql, resultList);
                        resultMap.put("[SQL" + (i + 1) + "] select result", resultList);
                        continue s;
                    } else {
                        int update = Db.use("sqlActuator").update(sql);
//                        log.info("SQL [{}] rows [{}]", sql, update);
                        resultMap.put("[SQL" + (i + 1) + "] " + word.toLowerCase() + " rows", update);
                        continue s;
                    }
                }
            }
        }
        return resultMap;
    }

    @Transactional(rollbackFor = Exception.class)
    public Object execSqlStr(String sqls) {
        if (debtArp == null) {
            debtDruidPlugin = new DruidPlugin(backdoorConfig.getDebtDbUrl(), backdoorConfig.getDebtDbUser(),
                    backdoorConfig.getDebtDbPwd(), "oracle.jdbc.driver.OracleDriver");
            debtArp = new ActiveRecordPlugin("sqlActuator", debtDruidPlugin);
            debtArp.setDialect(new OracleDialect());
            debtArp.setContainerFactory(new CaseInsensitiveContainerFactory());
            debtDruidPlugin.start();
            debtArp.start();
        }
        if (StrUtil.isBlank(sqls)) {
            throw new BizException(BaseCode.ERROR, "sql不能为空");
        }
        String[] sqlArr = sqls.split(";");
        if (backdoorConfig.isEnableTableCheck()) {
            checkTable(sqlArr);
        }
        Map<String, Object> resultMap = new LinkedHashMap<String, Object>();
        s:
        for (int i = 0; i < sqlArr.length; i++) {
            String sql = sqlArr[i];
            if (StrKit.notBlank(sql.trim())) {
                if (sql.indexOf("--") == 0) {
                    continue s;
                }
                String[] wordArr = sql.split(" ");
                for (String word : wordArr) {
                    word = word.toUpperCase();
                    if ("SELECT".equals(word)) {
                        List<Record> findList = Db.use("sqlActuator").find(sql);
                        List<Map<String, Object>> resultList = new ArrayList<Map<String, Object>>();
                        for (Record record : findList) {
                            resultList.add(record.getColumns());
                        }
//                        log.info("SQL [{}] select result [{}]", sql, resultList);
                        resultMap.put("[SQL" + (i + 1) + "] select result", resultList);
                        continue s;
                    } else {
                        int update = Db.use("sqlActuator").update(sql);
//                        log.info("SQL [{}] rows [{}]", sql, update);
                        resultMap.put("[SQL" + (i + 1) + "] " + word.toLowerCase() + " rows", update);
                        continue s;
                    }
                }
            }
        }
        return resultMap;
    }

    /**
     * 检查sql操作的表是否存在权限
     *
     * @param sqlArr
     */
    private void checkTable(String[] sqlArr) {
        log.info("检查sql操作的表是否存在权限");
        Set<String> deniedTableNameSet = Sets.newHashSet();
        for (String sql : sqlArr) {
            if (StrUtil.isNotBlank(sql.trim())) {
                if (sql.indexOf("--") == 0) {
                    continue;
                }
            }
            List<String> tableNameList = getAllTableNameBySQL(sql);
            for (String tableName : tableNameList) {
                if (!backdoorConfig.getWorkTableList().contains(tableName.toUpperCase())) {
                    deniedTableNameSet.add(tableName);
                }
            }
        }
        if (ObjectUtil.isNotEmpty(deniedTableNameSet)) {
            throw new BizException(BaseCode.ERROR, "表没有操作权限=>" + deniedTableNameSet);
        }
    }

    private static List<String> getAllTableNameBySQL(String sql) {
    	// 数据库为ORACLE
        String dbType = JdbcConstants.ORACLE;
        try {
            List<String> tableNameList = new ArrayList<>();
            //格式化输出
            String sqlResult = SQLUtils.format(sql, dbType);
            log.info("格式化后的sql:[{}]", sqlResult);

            List<SQLStatement> stmtList = SQLUtils.parseStatements(sql, dbType);
            if (ObjectUtil.isEmpty(stmtList)) {
                log.info("stmtList为空无需获取");
                return Collections.emptyList();
            }
            for (SQLStatement sqlStatement : stmtList) {
                OracleSchemaStatVisitor visitor = new OracleSchemaStatVisitor();
                sqlStatement.accept(visitor);
                Map<TableStat.Name, TableStat> tables = visitor.getTables();
                log.info("druid解析sql的结果集:[{}]", tables);
                Set<TableStat.Name> tableNameSet = tables.keySet();
                for (TableStat.Name name : tableNameSet) {
                    String tableName = name.getName();
                    if (StrUtil.isNotBlank(tableName)) {
                        tableNameList.add(tableName);
                    }
                }
            }
            log.info("解析sql后的表名:[{}]", tableNameList);
            return tableNameList;
        } catch (Exception e) {
            log.error("**************异常SQL:[{}]*****************\\n", sql);
            throw new BizException("SQL异常=>" + sql);
        }
    }

    private String readFile(File sqlFile) {
        InputStreamReader reader = null;
        BufferedReader bufReader = null;
        try {
            reader = new InputStreamReader(new FileInputStream(sqlFile));
            bufReader = new BufferedReader(reader);
            String line = "";
            String result = "";
            while ((line = bufReader.readLine()) != null) {
                result += line;
            }
            return result;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufReader != null) {
                    bufReader.close();
                }
                if (bufReader != null) {
                    bufReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

}

接口

package cn.window.debt.interfaces.back.controller;

import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import com.jfinal.kit.StrKit;
import cn.window.boot.base.api.enums.BaseCode;
import cn.window.boot.base.api.exception.BizException;
import cn.window.boot.base.api.response.R;
import cn.window.debt.infrastructure.config.BackdoorConfig;
import cn.window.debt.interfaces.back.actuator.SqlActuator;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.util.Arrays;

/**
 * backdoor接口
 */
@RestController
@Validated
@RequestMapping("/backdoor")
@Api(value = "backdoor", tags = "backdoor接口")
@Slf4j
public class BackdoorCtl {

    @Autowired
    private BackdoorConfig backdoorConfig;
    @Autowired
    private SqlActuator sqlActuator;

    @PostMapping("/v1/execSql")
    @ApiOperationSupport(order = 1)
    @ApiOperation(value = "执行sql", notes = "", httpMethod = "POST")
    public R<Object> execSql(MultipartFile file) {
        if (!backdoorConfig.isEnable()) {
            throw new BizException(BaseCode.ERROR, "backdoor未开启");
        }
        File tempFile = null;
        Object execSqlResult = null;
        try {
            log.info("**************** sql执行start ****************");
            String excelName = file.getOriginalFilename();
            String[] excelNameArr = excelName.split("\\.");
            if (excelNameArr.length == 2 && Arrays.asList("sql").contains(excelNameArr[1])) {
                tempFile = multipartFileToFile(file);
                execSqlResult = sqlActuator.execSql(tempFile);
            } else {
                log.error("不支持的数据导入文件");
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("执行sql异常", e);
            throw new BizException(BaseCode.SYSTEM_ERROR, e.getMessage());
        } finally {
            if (tempFile != null) {
                tempFile.delete();
            }
        }
        log.info("**************** sql执行end ****************");
        return R.success(execSqlResult);
    }

    @GetMapping("/v1/execSqlStr")
    @ApiOperationSupport(order = 1)
    @ApiOperation(value = "执行sql", notes = "", httpMethod = "GET")
    public R<Object> execSqlStr(String sqlStr) {
        if (!backdoorConfig.isEnable()) {
            throw new BizException(BaseCode.ERROR, "backdoor未开启");
        }
        Object execSqlResult = null;
        try {
            log.info("**************** sql执行start ****************");
            execSqlResult = sqlActuator.execSqlStr(sqlStr);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("执行sql异常", e);
            throw new BizException(BaseCode.SYSTEM_ERROR, e.getMessage());
        }
        log.info("**************** sql执行end ****************");
        return R.success(execSqlResult);
    }


    private File multipartFileToFile(MultipartFile file) {
        File toFile = null;
        try {
            if (file != null && file.getSize() > 0) {
                InputStream ins = null;
                ins = file.getInputStream();
                toFile = new File(StrKit.getRandomUUID() + "-" + file.getOriginalFilename());
                inputStreamToFile(ins, toFile);
                ins.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return toFile;
    }

    private static void inputStreamToFile(InputStream ins, File file) {
        try {
            OutputStream os = new FileOutputStream(file);
            int bytesRead = 0;
            byte[] buffer = new byte[8192];
            while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.close();
            ins.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Nacos配置

debt.backdoor.enable=true
debt.backdoor.enableTableCheck=false
debt.backdoor.debtDbUrl=
debt.backdoor.debtDbUser=
debt.backdoor.debtDbPwd=
debt.backdoor.workTables=

测试

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

哲学长
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据库--SqlServer详解
李宥的博客
11-08 5万+
数据库–SQLServer详解 零、文章目录 一、数据库概念 1、数据库基本概念 （1）数据库(DataBase:DB) 数据库是是按照数据结构来组织、存储和管理数据的仓库。---->存储和管理数据的仓库 （2）数据库管理系统（Database Management System:DBMS） 是专门用于管理数据库的计算机系统软件。数据库管理系统能够为数据库提供数据的定义、建立、维护、查询和统计等操作功能，并完成对数据完整性、安全性进行控制的功能。 注意：我们一般说的数据库，就是指的DBMS 2、数据库
oracle数据库慢查询SQL
喜羊羊love红太狼
02-01 3792
SQL语句文本不同：即使SQL语句的逻辑相同，但如果SQL语句的文本不同（比如空格、大小写等），Oracle也会将它们当作不同的SQL语句进行处理。绑定变量不同：如果SQL语句使用了绑定变量，即在SQL语句中使用了占位符，那么不同的绑定变量值会导致不同的SQL语句被加入到共享池中。不同的解析环境：在不同的解析环境下，相同的SQL语句可能会被多次解析并加载到共享池中，比如在不同的会话或者不同的数据库连接中。但是分页查询总数的sql语句执行五次，5.932s，3.78s，2.89s, 2.5s，1.9s。
Oracle数据库是如何执行SQL的
独孤清扬玩DB
06-07 2286
文章目录1、参考资料2、Oracle SQL执行过程2.1、SQL语句的执行过程2.1.1、全局角度来看SQL请求的执行过程2.1.2、数据库端处理SQL具体过程2.2、Oracle对解析过程的优化2.2.1、减少硬解析 -- 软解析(Soft parse)2.2.2、进一步减少软解析 -- 软软解析(Soft soft parse)2.2.3、一次解析，多次执行 -- 客户端语句缓存(statement cache)2.2.4、最高境界，不执行sql -- SQL结果集缓存 1、参考资料 oracle c
Sql server 连接 Oracle数据库
咔咔啦啦朵朵
09-04 7709
Sql server 连接 Oracle数据库
SQL SEVER2012链接Oracle数据库方法
qq_38903177的博客
10-19 4359
SQL SEVER2012链接Oracle数据库方法
python操作oracle数据库-查询
weixin_45625815的博客
12-31 1187
python操作oracle数据库-查询 参照文档 http://www.oracle.com/technetwork/cn/articles/dsl/mastering-oracle-python-1391323-zhs.html http://cx-oracle.readthedocs.io/en/latest/module.html DB API 2.0 和 cx_Oracle 介绍 Pyt...
sql数据库读取oracle数据库,SQL Server 数据导入Oracle数据库（脚本实现）
weixin_35110758的博客
04-04 651
我们知道SQL Server在2005以后提供了DTS导出数据功能，可以将SQL Server数据库端数据导入到SQL Server，MySQL,Excel，Access以及Oracle等我们常用的数据库。然而在SQL Server 2005 Express 2005版本上没有这个功能，也就不能完成SQL Server 端数据导入到Oracle数据库中。这时候我们有什么办法可以解决SQL Serv...
C#系列-访问SqlServer+Mysql+Oracle数据库（6）
赵玉的专栏
02-09 1473
在C#中访问SQL Server数据库，你通常会使用ADO.NET (ActiveX Data Objects .NET)，它是.NET Framework提供的一组用于访问数据的类库。最后，确保你的项目引用了正确的SQL Server客户端库。你需要将其中的`你的服务器地址`、`你的数据库名`、`你的用户名`和`你的密码`替换为实际的值。你需要将其中的你的服务器地址、你的数据库名、你的用户名和你的密码替换为实际的值。你需要将其中的你的用户名、你的密码和你的Oracle服务名替换为实际的值。
Oracle数据库常用Sql语句大全
不忘初心，执迷不悔
07-19 7452
最简单的就是查询：select语句 数据库操作语言DML：update、insert、delete等 数据库定义语言DDL：create、drop、alter等等 oracle取前几条数据语句 sqlserver中可以用top n 的方法，oracle中用 rownum，但如果只用 rownum会随机取数据，如果想按一定顺序取前几条数据 则可这样写： select * from (select列 from 表 where 条件 order by列 desc) where rownum<> sel
oracle sql执行计划分析
iloki的博客
05-09 3995
sql执行计划分析问题描述问题分析解决方案扫描类型index range scan(索引范围扫描)：index skip scan(索引跳跃式扫描)table access full（全表扫描） 问题描述 项目上反馈某个功能模块查询效率特别慢，接口响应一次要四分钟，使用jprofiler分析后发现有一个慢sql，如下： SELECT T.* FROM (select t0.ID as c_1, t0.TITLE as c_2,
Java操作Oracle数据库-多线程.rar
07-10
2. **Oracle数据库操作**：一旦建立了连接，我们可以通过`Statement`或`PreparedStatement`对象来执行SQL语句，包括查询、插入、更新和删除数据。在本示例中，还涉及到调用Oracle数据库中的函数和存储过程，这通常...
oracle-TO-SQL.zip_DELPHI 数据库_delphi_delphi oracle_oracle
09-21
2. 查询Oracle数据：通过TOracleQuery或类似组件，执行SQL语句，获取需要迁移的数据。 3. 设计数据映射：分析Oracle数据库的表结构和字段，将其映射到目标SQL数据库的相应表和字段。这一步可能涉及到数据类型的转换...
ORACLE-SQL语句学习教程解读.pdf
06-24
SQL*PLUS是一个命令行接口，允许用户直接与Oracle数据库交互，执行SQL语句和PL/SQL块。它提供了基本的编辑、执行和结果查看功能，对于学习和调试SQL非常有用。 “第二章”至“第十五章”会逐步讲解SQL的关键元素： ...
易语言连接Oracle数据库源码-易语言
06-13
而易语言通过特定的接口或组件，可以与Oracle数据库进行交互，实现数据的读取、写入和更新等操作。 在易语言中连接Oracle数据库，通常会用到以下知识点： 1. 数据库驱动：首先，你需要安装Oracle的客户端或者使用...
Java连接SQLServer和Oracle数据库.zip
07-07
4. 执行SQL：通过Connection对象创建Statement或PreparedStatement对象，然后调用executeQuery()或executeUpdate()方法执行SQL。 5. 处理结果：对于查询语句，可以获取ResultSet对象来遍历结果；对于更新语句，可以...
图数据库查询与操作指南-以Nebula图数据库为例
DZSpace，专注于计算机科学与技术领域的技术博主，致力于分享实用知识与技巧，帮助读者快速掌握技术要点，共同探索计算机世界的无限可能。欢迎访问DZSpace的博客，一起学习进步！
07-26 300
图数据库查询与操作指南-以Nebula图数据库为例
ODBC连接达梦数据库
qq_55187735的博客
07-24 282
用户执行，因为环境变量配置在。
SQL基础入门：解锁数据库管理的钥匙
最新发布
WayneYalejk的博客
07-26 444
在数字化时代，数据已成为企业最宝贵的资产之一。为了高效地存储、查询和管理这些数据，SQL（Structured Query Language，结构化查询语言）应运而生。SQL不仅是数据库管理员的必备技能，也是数据分析师、开发人员等多个领域从业者的重要工具。本文将带您踏入SQL的世界，从基础概念到实际应用，一步步解锁数据库管理的钥匙。强调SQL在数据处理和分析中的重要性，鼓励读者通过实践不断深化对SQL的理解和应用。
sqlalchemy使用json_unquote函数的mysql like查询
ithongchou的博客
07-23 1342
为您自己的数据库连接信息，并根据实际表结构修改模型类。函数查询MySQL JSON字段可以通过使用。下面是一个示例，假设有一个名为。请确保替换示例代码中的数据库连接字符串(在SQLAlchemy中使用。的表，其中包含一个名为。
Oracle数据库系统：SQL*PLUS实战指南
"Oracle数据库系统应用开发实用教程电子课件第三章主要讲解如何使用SQL*PLUS，这是一个重要的Oracle数据库管理工具，支持标准SQL并提供额外的命令，用于数据库管理、查询、应用程序开发以及PL/SQL程序调试。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值