qidao123.com技术社区-IT企服评测·应用市场»论坛 › 数据库 › Oracle › 使用sql查询excel内容

使用sql查询excel内容

[复制链接]
发表于 2025-11-4 19:50:31 | 显示全部楼层 |阅读模式
1. 简介


我们在前面的文章中提到了calcite支持csv和json文件的数据源适配, 实在就是将文件分析成表然后以文件夹为schema, 然后将天生的schema注册到RootSehema(RootSchema是全部数据源schema的parent，多个差别数据源schema可以挂在同一个RootSchema下)下, 终极使用calcite的特性举行sql的分析查询返回.

但实在我们的数据文件一样平常使用excel举行存储,流转, 但很惋惜, calcite本身没有excel的适配器, 但实在我们可以模仿calcite-file, 本身搞一个calcite-file-excel, 也可以认识calcite的工作原理.

2. 实现思绪


由于excel有sheet的概念, 以是可以将一个excel分析成schema, 每个sheet分析成table, 实现步调如下:


  • 实现SchemaFactory重写create方法: schema工厂 用于创建schema
  • 继续AbstractSchema: schema形貌类 用于分析excel, 创建table(分析sheet)
  • 继续AbstractTable, ScannableTable: table形貌类 提供字段信息和数据内容等(分析sheet data)

3. Excel样例


excel有两个sheet页, 分别是user_info 和 role_info如下:







ok, 万事具备.

4. Maven


  1. <dependency>
  2.     <groupId>org.apache.poi</groupId>
  3.     <artifactId>poi-ooxml</artifactId>
  4.     <version>5.2.3</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>org.apache.poi</groupId>
  9.     <artifactId>poi</artifactId>
  10.     <version>5.2.3</version>
  11. </dependency>
  13. <dependency>
  14.     <groupId>org.apache.calcite</groupId>
  15.     <artifactId>calcite-core</artifactId>
  16.     <version>1.37.0</version>
  17. </dependency>
复制代码

5. 焦点代码


5.1 SchemaFactory


  1. package com.ldx.calcite.excel;
  3. import com.google.common.collect.Lists;
  4. import org.apache.calcite.schema.Schema;
  5. import org.apache.calcite.schema.SchemaFactory;
  6. import org.apache.calcite.schema.SchemaPlus;
  7. import org.apache.commons.lang3.ObjectUtils;
  8. import org.apache.commons.lang3.StringUtils;
  10. import java.io.File;
  11. import java.util.List;
  12. import java.util.Map;
  14. /**
  15. * schema factory
  16. */
  17. public class ExcelSchemaFactory implements SchemaFactory {
  18.     public final static ExcelSchemaFactory INSTANCE = new ExcelSchemaFactory();
  20.     private ExcelSchemaFactory(){}
  22.     @Override
  23.     public Schema create(SchemaPlus parentSchema, String name, Map<String, Object> operand) {
  24.         final Object filePath = operand.get("filePath");
  26.         if (ObjectUtils.isEmpty(filePath)) {
  27.             throw new NullPointerException("can not find excel file");
  28.         }
  30.         return this.create(filePath.toString());
  31.     }
  33.     public Schema create(String excelFilePath) {
  34.         if (StringUtils.isBlank(excelFilePath)) {
  35.             throw new NullPointerException("can not find excel file");
  36.         }
  38.         return this.create(new File(excelFilePath));
  39.     }
  41.     public Schema create(File excelFile) {
  42.         if (ObjectUtils.isEmpty(excelFile) || !excelFile.exists()) {
  43.             throw new NullPointerException("can not find excel file");
  44.         }
  46.         if (!excelFile.isFile() || !isExcelFile(excelFile)) {
  47.             throw new RuntimeException("can not find excel file: " + excelFile.getAbsolutePath());
  48.         }
  50.         return new ExcelSchema(excelFile);
  51.     }
  53.     protected List<String> supportedFileSuffix() {
  54.         return Lists.newArrayList("xls", "xlsx");
  55.     }
  57.     private boolean isExcelFile(File excelFile) {
  58.         if (ObjectUtils.isEmpty(excelFile)) {
  59.             return false;
  60.         }
  62.         final String name = excelFile.getName();
  63.         return StringUtils.endsWithAny(name, this.supportedFileSuffix().toArray(new String[0]));
  64.     }
  65. }
复制代码

schema中有多个重载的create方法用于方便的创建schema, 终极将excel file 交给ExcelSchema创建一个schema对象

5.2 Schema


  1. package com.ldx.calcite.excel;
  3. import org.apache.calcite.schema.Table;
  4. import org.apache.calcite.schema.impl.AbstractSchema;
  5. import org.apache.commons.lang3.ObjectUtils;
  6. import org.apache.poi.ss.usermodel.Sheet;
  7. import org.apache.poi.ss.usermodel.Workbook;
  8. import org.apache.poi.ss.usermodel.WorkbookFactory;
  9. import org.testng.collections.Maps;
  11. import java.io.File;
  12. import java.util.Iterator;
  13. import java.util.Map;
  15. /**
  16. * schema
  17. */
  18. public class ExcelSchema extends AbstractSchema {
  19.     private final File excelFile;
  21.     private Map<String, Table> tableMap;
  23.     public ExcelSchema(File excelFile) {
  24.         this.excelFile = excelFile;
  25.     }
  27.     @Override
  28.     protected Map<String, Table> getTableMap() {
  29.         if (ObjectUtils.isEmpty(tableMap)) {
  30.             tableMap = createTableMap();
  31.         }
  33.         return tableMap;
  34.     }
  36.     private Map<String, Table> createTableMap() {
  37.         final Map<String, Table> result = Maps.newHashMap();
  39.         try (Workbook workbook = WorkbookFactory.create(excelFile)) {
  40.             final Iterator<Sheet> sheetIterator = workbook.sheetIterator();
  42.             while (sheetIterator.hasNext()) {
  43.                 final Sheet sheet = sheetIterator.next();
  44.                 final ExcelScannableTable excelScannableTable = new ExcelScannableTable(sheet, null);
  45.                 result.put(sheet.getSheetName(), excelScannableTable);
  46.             }
  47.         }
  48.         catch (Exception ignored) {}
  50.         return result;
  51.     }
  52. }
复制代码

schema类读取Excel file, 并循环读取sheet, 将每个sheet分析成ExcelScannableTable并存储

5.3 Table


  1. package com.ldx.calcite.excel;
  3. import com.google.common.collect.Lists;
  4. import com.ldx.calcite.excel.enums.JavaFileTypeEnum;
  5. import org.apache.calcite.DataContext;
  6. import org.apache.calcite.adapter.java.JavaTypeFactory;
  7. import org.apache.calcite.linq4j.Enumerable;
  8. import org.apache.calcite.linq4j.Linq4j;
  9. import org.apache.calcite.rel.type.RelDataType;
  10. import org.apache.calcite.rel.type.RelDataTypeFactory;
  11. import org.apache.calcite.rel.type.RelProtoDataType;
  12. import org.apache.calcite.schema.ScannableTable;
  13. import org.apache.calcite.schema.impl.AbstractTable;
  14. import org.apache.calcite.sql.type.SqlTypeName;
  15. import org.apache.calcite.util.Pair;
  16. import org.apache.commons.lang3.ObjectUtils;
  17. import org.apache.poi.ss.usermodel.Cell;
  18. import org.apache.poi.ss.usermodel.Row;
  19. import org.apache.poi.ss.usermodel.Sheet;
  20. import org.checkerframework.checker.nullness.qual.Nullable;
  22. import java.util.List;
  24. /**
  25. * table
  26. */
  27. public class ExcelScannableTable extends AbstractTable implements ScannableTable {
  28.     private final RelProtoDataType protoRowType;
  30.     private final Sheet sheet;
  32.     private RelDataType rowType;
  34.     private List<JavaFileTypeEnum> fieldTypes;
  36.     private List<Object[]> rowDataList;
  38.     public ExcelScannableTable(Sheet sheet, RelProtoDataType protoRowType) {
  39.         this.protoRowType = protoRowType;
  40.         this.sheet = sheet;
  41.     }
  43.     @Override
  44.     public Enumerable<@Nullable Object[]> scan(DataContext root) {
  45.         JavaTypeFactory typeFactory = root.getTypeFactory();
  46.         final List<JavaFileTypeEnum> fieldTypes = this.getFieldTypes(typeFactory);
  48.         if (rowDataList == null) {
  49.             rowDataList = readExcelData(sheet, fieldTypes);
  50.         }
  52.         return Linq4j.asEnumerable(rowDataList);
  53.     }
  55.     @Override
  56.     public RelDataType getRowType(RelDataTypeFactory typeFactory) {
  57.         if (ObjectUtils.isNotEmpty(protoRowType)) {
  58.             return protoRowType.apply(typeFactory);
  59.         }
  61.         if (ObjectUtils.isEmpty(rowType)) {
  62.             rowType = deduceRowType((JavaTypeFactory) typeFactory, sheet, null);
  63.         }
  65.         return rowType;
  66.     }
  68.     public List<JavaFileTypeEnum> getFieldTypes(RelDataTypeFactory typeFactory) {
  69.         if (fieldTypes == null) {
  70.             fieldTypes = Lists.newArrayList();
  71.             deduceRowType((JavaTypeFactory) typeFactory, sheet, fieldTypes);
  72.         }
  73.         return fieldTypes;
  74.     }
  76.     private List<Object[]> readExcelData(Sheet sheet, List<JavaFileTypeEnum> fieldTypes) {
  77.         List<Object[]> rowDataList = Lists.newArrayList();
  79.         for (int rowIndex = 1; rowIndex <= sheet.getLastRowNum(); rowIndex++) {
  80.             Row row = sheet.getRow(rowIndex);
  81.             Object[] rowData = new Object[fieldTypes.size()];
  83.             for (int i = 0; i < row.getLastCellNum(); i++) {
  84.                 final JavaFileTypeEnum javaFileTypeEnum = fieldTypes.get(i);
  85.                 Cell cell = row.getCell(i, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
  86.                 final Object cellValue = javaFileTypeEnum.getCellValue(cell);
  87.                 rowData[i] = cellValue;
  88.             }
  90.             rowDataList.add(rowData);
  91.         }
  93.         return rowDataList;
  94.     }
  96.     public static RelDataType deduceRowType(JavaTypeFactory typeFactory, Sheet sheet, List<JavaFileTypeEnum> fieldTypes) {
  97.         final List<String> names = Lists.newArrayList();
  98.         final List<RelDataType> types = Lists.newArrayList();
  100.         if (sheet != null) {
  101.             Row headerRow = sheet.getRow(0);
  103.             if (headerRow != null) {
  104.                 for (int i = 0; i < headerRow.getLastCellNum(); i++) {
  105.                     Cell cell = headerRow.getCell(i, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
  106.                     String[] columnInfo = cell
  107.                             .getStringCellValue()
  108.                             .split(":");
  109.                     String columnName = columnInfo[0].trim();
  110.                     String columnType = null;
  112.                     if (columnInfo.length == 2) {
  113.                         columnType = columnInfo[1].trim();
  114.                     }
  116.                     final JavaFileTypeEnum javaFileType = JavaFileTypeEnum
  117.                             .of(columnType)
  118.                             .orElse(JavaFileTypeEnum.UNKNOWN);
  119.                     final RelDataType sqlType = typeFactory.createSqlType(javaFileType.getSqlTypeName());
  120.                     names.add(columnName);
  121.                     types.add(sqlType);
  123.                     if (fieldTypes != null) {
  124.                         fieldTypes.add(javaFileType);
  125.                     }
  126.                 }
  127.             }
  128.         }
  130.         if (names.isEmpty()) {
  131.             names.add("line");
  132.             types.add(typeFactory.createSqlType(SqlTypeName.VARCHAR));
  133.         }
  135.         return typeFactory.createStructType(Pair.zip(names, types));
  136.     }
  137. }
复制代码

table类中此中有两个比力关键的方法

​ scan: 扫描表内容, 我们这里将sheet页面的数据内容分析存储末了交给calcite

​ getRowType: 获取字段信息, 我们这里默认使用第一条纪录作为表头(row[0]) 并分析为字段信息, 字段规则跟csv一样 name:string, 冒号前面的是字段key, 冒号背面的是字段范例, 如果未指定字段范例, 则分析为UNKNOWN, 后续JavaFileTypeEnum会举行范例推断, 终极在效果处置惩罚时calcite也会举行推断

deduceRowType: 推断字段范例, 方法中使用JavaFileTypeEnum罗列类对java type & sql type & 字段值转化处置惩罚方法 举行管理

5.4 ColumnTypeEnum


  1. package com.ldx.calcite.excel.enums;
  3. import lombok.Getter;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.calcite.avatica.util.DateTimeUtils;
  6. import org.apache.calcite.sql.type.SqlTypeName;
  7. import org.apache.commons.lang3.ObjectUtils;
  8. import org.apache.commons.lang3.StringUtils;
  9. import org.apache.commons.lang3.time.FastDateFormat;
  10. import org.apache.poi.ss.usermodel.Cell;
  11. import org.apache.poi.ss.usermodel.DateUtil;
  12. import org.apache.poi.ss.util.CellUtil;
  14. import java.text.ParseException;
  15. import java.text.SimpleDateFormat;
  16. import java.util.Arrays;
  17. import java.util.Date;
  18. import java.util.Optional;
  19. import java.util.TimeZone;
  20. import java.util.function.Function;
  22. /**
  23. * type converter
  24. */
  25. @Slf4j
  26. @Getter
  27. public enum JavaFileTypeEnum {
  28.     STRING("string", SqlTypeName.VARCHAR, Cell::getStringCellValue),
  29.     BOOLEAN("boolean", SqlTypeName.BOOLEAN, Cell::getBooleanCellValue),
  30.     BYTE("byte", SqlTypeName.TINYINT, Cell::getStringCellValue),
  31.     CHAR("char", SqlTypeName.CHAR, Cell::getStringCellValue),
  32.     SHORT("short", SqlTypeName.SMALLINT, Cell::getNumericCellValue),
  33.     INT("int", SqlTypeName.INTEGER, cell -> (Double.valueOf(cell.getNumericCellValue()).intValue())),
  34.     LONG("long", SqlTypeName.BIGINT, cell -> (Double.valueOf(cell.getNumericCellValue()).longValue())),
  35.     FLOAT("float", SqlTypeName.REAL, Cell::getNumericCellValue),
  36.     DOUBLE("double", SqlTypeName.DOUBLE, Cell::getNumericCellValue),
  37.     DATE("date", SqlTypeName.DATE, getValueWithDate()),
  38.     TIMESTAMP("timestamp", SqlTypeName.TIMESTAMP, getValueWithTimestamp()),
  39.     TIME("time", SqlTypeName.TIME, getValueWithTime()),
  40.     UNKNOWN("unknown", SqlTypeName.UNKNOWN, getValueWithUnknown()),;
  41.     // cell type
  42.     private final String typeName;
  43.                 // sql type
  44.     private final SqlTypeName sqlTypeName;
  45.     // value convert func
  46.     private final Function<Cell, Object> cellValueFunc;
  48.     private static final FastDateFormat TIME_FORMAT_DATE;
  50.     private static final FastDateFormat TIME_FORMAT_TIME;
  52.     private static final FastDateFormat TIME_FORMAT_TIMESTAMP;
  54.     static {
  55.         final TimeZone gmt = TimeZone.getTimeZone("GMT");
  56.         TIME_FORMAT_DATE = FastDateFormat.getInstance("yyyy-MM-dd", gmt);
  57.         TIME_FORMAT_TIME = FastDateFormat.getInstance("HH:mm:ss", gmt);
  58.         TIME_FORMAT_TIMESTAMP = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss", gmt);
  59.     }
  61.     JavaFileTypeEnum(String typeName, SqlTypeName sqlTypeName, Function<Cell, Object> cellValueFunc) {
  62.         this.typeName = typeName;
  63.         this.sqlTypeName = sqlTypeName;
  64.         this.cellValueFunc = cellValueFunc;
  65.     }
  67.     public static Optional<JavaFileTypeEnum> of(String typeName) {
  68.         return Arrays
  69.                 .stream(values())
  70.                 .filter(type -> StringUtils.equalsIgnoreCase(typeName, type.getTypeName()))
  71.                 .findFirst();
  72.     }
  74.     public static SqlTypeName findSqlTypeName(String typeName) {
  75.         final Optional<JavaFileTypeEnum> javaFileTypeOptional = of(typeName);
  77.         if (javaFileTypeOptional.isPresent()) {
  78.             return javaFileTypeOptional
  79.                     .get()
  80.                     .getSqlTypeName();
  81.         }
  83.         return SqlTypeName.UNKNOWN;
  84.     }
  86.     public Object getCellValue(Cell cell) {
  87.         return cellValueFunc.apply(cell);
  88.     }
  90.     public static Function<Cell, Object> getValueWithUnknown() {
  91.         return cell -> {
  92.             if (ObjectUtils.isEmpty(cell)) {
  93.                 return null;
  94.             }
  96.             switch (cell.getCellType()) {
  97.                 case STRING:
  98.                     return cell.getStringCellValue();
  99.                 case NUMERIC:
  100.                     if (DateUtil.isCellDateFormatted(cell)) {
  101.                         // 如果是日期类型，返回日期对象
  102.                         return cell.getDateCellValue();
  103.                     }
  104.                     else {
  105.                         // 否则返回数值
  106.                         return cell.getNumericCellValue();
  107.                     }
  108.                 case BOOLEAN:
  109.                     return cell.getBooleanCellValue();
  110.                 case FORMULA:
  111.                     // 对于公式单元格，先计算公式结果，再获取其值
  112.                     try {
  113.                         return cell.getNumericCellValue();
  114.                     }
  115.                     catch (Exception e) {
  116.                         try {
  117.                             return cell.getStringCellValue();
  118.                         }
  119.                         catch (Exception ex) {
  120.                             log.error("parse unknown data error, cellRowIndex:{}, cellColumnIndex:{}", cell.getRowIndex(), cell.getColumnIndex(), e);
  121.                             return null;
  122.                         }
  123.                     }
  124.                 case BLANK:
  125.                     return "";
  126.                 default:
  127.                     return null;
  128.             }
  129.         };
  130.     }
  132.     public static Function<Cell, Object> getValueWithDate() {
  133.         return cell -> {
  134.             Date date = cell.getDateCellValue();
  136.             if(ObjectUtils.isEmpty(date)) {
  137.                 return null;
  138.             }
  140.             try {
  141.                 final String formated = new SimpleDateFormat("yyyy-MM-dd").format(date);
  142.                 Date newDate = TIME_FORMAT_DATE.parse(formated);
  143.                 return (int) (newDate.getTime() / DateTimeUtils.MILLIS_PER_DAY);
  144.             }
  145.             catch (ParseException e) {
  146.                 log.error("parse date error, date:{}", date, e);
  147.             }
  149.             return null;
  150.         };
  151.     }
  153.     public static Function<Cell, Object> getValueWithTimestamp() {
  154.         return cell -> {
  155.             Date date = cell.getDateCellValue();
  157.             if(ObjectUtils.isEmpty(date)) {
  158.                 return null;
  159.             }
  161.             try {
  162.                 final String formated = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
  163.                 Date newDate = TIME_FORMAT_TIMESTAMP.parse(formated);
  164.                 return (int) newDate.getTime();
  165.             }
  166.             catch (ParseException e) {
  167.                 log.error("parse timestamp error, date:{}", date, e);
  168.             }
  170.             return null;
  171.         };
  172.     }
  174.     public static Function<Cell, Object> getValueWithTime() {
  175.         return cell -> {
  176.             Date date = cell.getDateCellValue();
  178.             if(ObjectUtils.isEmpty(date)) {
  179.                 return null;
  180.             }
  182.             try {
  183.                 final String formated = new SimpleDateFormat("HH:mm:ss").format(date);
  184.                 Date newDate = TIME_FORMAT_TIME.parse(formated);
  185.                 return newDate.getTime();
  186.             }
  187.             catch (ParseException e) {
  188.                 log.error("parse time error, date:{}", date, e);
  189.             }
  191.             return null;
  192.         };
  193.     }
  194. }
复制代码

该罗列类紧张管理了java type& sql type & cell value convert func, 方便同一管理范例映射及单位格内容提取时的转换方法(这里借用了java8 function函数特性)

   注: 这里的日期转换只能如许写, 纵然用GMT的时区(抄的calcite-file), 要否则输出的日期时间不绝偶尔差...
  
6. 测试查询


  1. package com.ldx.calcite;
  3. import com.ldx.calcite.excel.ExcelSchemaFactory;
  4. import lombok.SneakyThrows;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.apache.calcite.config.CalciteConnectionProperty;
  7. import org.apache.calcite.jdbc.CalciteConnection;
  8. import org.apache.calcite.schema.Schema;
  9. import org.apache.calcite.schema.SchemaPlus;
  10. import org.apache.calcite.util.Sources;
  11. import org.junit.jupiter.api.AfterAll;
  12. import org.junit.jupiter.api.BeforeAll;
  13. import org.junit.jupiter.api.Test;
  14. import org.testng.collections.Maps;
  16. import java.net.URL;
  17. import java.sql.Connection;
  18. import java.sql.DriverManager;
  19. import java.sql.ResultSet;
  20. import java.sql.ResultSetMetaData;
  21. import java.sql.SQLException;
  22. import java.sql.Statement;
  23. import java.util.Map;
  24. import java.util.Properties;
  26. @Slf4j
  27. public class CalciteExcelTest {
  28.     private static Connection connection;
  30.     private static SchemaPlus rootSchema;
  32.     private static CalciteConnection calciteConnection;
  34.     @BeforeAll
  35.     @SneakyThrows
  36.     public static void beforeAll() {
  37.         Properties info = new Properties();
  38.         // 不区分sql大小写
  39.         info.setProperty(CalciteConnectionProperty.CASE_SENSITIVE.camelName(), "false");
  41.         // 创建Calcite连接
  42.         connection = DriverManager.getConnection("jdbc:calcite:", info);
  43.         calciteConnection = connection.unwrap(CalciteConnection.class);
  44.         // 构建RootSchema，在Calcite中，RootSchema是所有数据源schema的parent，多个不同数据源schema可以挂在同一个RootSchema下
  45.         rootSchema = calciteConnection.getRootSchema();
  46.     }
  48.     @Test
  49.     @SneakyThrows
  50.     public void test_execute_query() {
  51.         final Schema schema = ExcelSchemaFactory.INSTANCE.create(resourcePath("file/test.xlsx"));
  52.         rootSchema.add("test", schema);
  53.         // 设置默认的schema
  54.         calciteConnection.setSchema("test");
  55.         final Statement statement = calciteConnection.createStatement();
  56.         ResultSet resultSet = statement.executeQuery("SELECT * FROM user_info");
  57.         printResultSet(resultSet);
  58.         System.out.println("=========");
  59.         ResultSet resultSet2 = statement.executeQuery("SELECT * FROM test.user_info where id > 110 and birthday > '2003-01-01'");
  60.         printResultSet(resultSet2);
  61.         System.out.println("=========");
  62.         ResultSet resultSet3 = statement.executeQuery("SELECT * FROM test.user_info ui inner join  test.role_info ri on ui.role_id = ri.id");
  63.         printResultSet(resultSet3);
  64.     }
  66.     @AfterAll
  67.     @SneakyThrows
  68.     public static void closeResource() {
  69.         connection.close();
  70.     }
  72.     private static String resourcePath(String path) {
  73.         final URL url = CalciteExcelTest.class.getResource("/" + path);
  74.         return Sources.of(url).file().getAbsolutePath();
  75.     }
  77.     public static void printResultSet(ResultSet resultSet) throws SQLException {
  78.         // 获取 ResultSet 元数据
  79.         ResultSetMetaData metaData = resultSet.getMetaData();
  81.         // 获取列数
  82.         int columnCount = metaData.getColumnCount();
  83.         log.info("Number of columns: {}",columnCount);
  85.         // 遍历 ResultSet 并打印结果
  86.         while (resultSet.next()) {
  87.             final Map<String, String> item = Maps.newHashMap();
  88.             // 遍历每一列并打印
  89.             for (int i = 1; i <= columnCount; i++) {
  90.                 String columnName = metaData.getColumnName(i);
  91.                 String columnValue = resultSet.getString(i);
  92.                 item.put(columnName, columnValue);
  93.             }
  95.             log.info(item.toString());
  96.         }
  97.     }
  98. }
复制代码

测试效果如下:




   文章转载自：张铁牛
  原文链接：4. 使用sql查询excel内容 - 张铁牛 - 博客园
  体验地点：引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程计划器_表单引擎_工作流引擎_软件架构

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
继续阅读请点击广告

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表

我可以不吃啊
+ 我要发帖
×
登录参与点评抽奖，加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表