Presto 是一个分布式的 SQL 查询引擎，非常适合用于 OLAP 场景。官方也许因为版权原因没有提供 oracle 的插件，oracle 在实际场景中还是使用的非常多的，有必要介绍些插件开发的流程。如果读者只是部署，不做开发，可以 clone 我托管在 GitHub 的Presto来进行编译、部署。

搭建开发环境

关于如何搭建开发环境，presto 的 github 首页已经给出教程，这里不再赘述。但是要注意presto 在 windows 平台下会编译失败，而且对源码开发之前必须要先编译 presto。这里推荐使用 IntelliJIDEA 作为开发的 IDE， 如果你已经将 presto 导入到 IDE 中，并且成功运行“PrestoServer”，那么你已经成功一半了，其实在 github 上面有人已经托管了presto-oracle这个插件，但是这个插件只能满足简单的查询，无法通过 presto 向 oracle 中插入数据。而且它这个不是集成到 presto 的源码中的，无法对插件进行调试。

新建 module

官方已经编写了 MySQL 插件，我们可以按照这个模板来开发。我们在 Presto 的根目录下新建 module，该 module 的 pom 信息如下：

  1. <?xml version="1.0"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  5.   <parent>
  6.     <groupId>com.facebook.presto</groupId>
  7.     <artifactId>presto-root</artifactId>
  8.     <version>0.157.2-SNAPSHOT</version>
  9.   </parent>
  11.   <artifactId>presto-oracle</artifactId>
  12.   <description>Presto - Oracle Connector</description>
  13.   <packaging>presto-plugin</packaging>
  15.   <properties>
  16.     <!--check license-->
  17.     <air.main.basedir>${project.parent.basedir}</air.main.basedir>
  18.   </properties>
  20.   <dependencies>
  21.     <dependency>
  22.       <groupId>com.facebook.presto</groupId>
  23.       <artifactId>presto-base-jdbc</artifactId>
  24.     </dependency>
  26.     <dependency>
  27.       <groupId>io.airlift</groupId>
  28.       <artifactId>configuration</artifactId>
  29.     </dependency>
  31.     <dependency>
  32.       <groupId>com.google.guava</groupId>
  33.       <artifactId>guava</artifactId>
  34.     </dependency>
  36.     <dependency>
  37.       <groupId>com.google.inject</groupId>
  38.       <artifactId>guice</artifactId>
  39.     </dependency>
  41.     <dependency>
  42.       <groupId>javax.validation</groupId>
  43.       <artifactId>validation-api</artifactId>
  44.     </dependency>
  46.     <dependency>
  47.       <groupId>com.oracle</groupId>
  48.       <artifactId>ojdbc6</artifactId>
  49.     </dependency>
  51.     <dependency>
  52.       <groupId>javax.inject</groupId>
  53.       <artifactId>javax.inject</artifactId>
  54.     </dependency>
  56.     <!-- Presto SPI -->
  57.     <dependency>
  58.       <groupId>com.facebook.presto</groupId>
  59.       <artifactId>presto-spi</artifactId>
  60.       <scope>provided</scope>
  61.     </dependency>
  63.     <dependency>
  64.       <groupId>io.airlift</groupId>
  65.       <artifactId>slice</artifactId>
  66.       <scope>provided</scope>
  67.     </dependency>
  69.     <dependency>
  70.       <groupId>io.airlift</groupId>
  71.       <artifactId>units</artifactId>
  72.       <scope>provided</scope>
  73.     </dependency>
  75.     <dependency>
  76.       <groupId>com.fasterxml.jackson.core</groupId>
  77.       <artifactId>jackson-annotations</artifactId>
  78.       <scope>provided</scope>
  79.     </dependency>
  81.     <!-- for testing -->
  82.     <dependency>
  83.       <groupId>org.testng</groupId>
  84.       <artifactId>testng</artifactId>
  85.       <scope>test</scope>
  86.     </dependency>
  88.     <dependency>
  89.       <groupId>io.airlift</groupId>
  90.       <artifactId>testing</artifactId>
  91.       <scope>test</scope>
  92.     </dependency>
  94.     <dependency>
  95.       <groupId>io.airlift</groupId>
  96.       <artifactId>json</artifactId>
  97.       <scope>test</scope>
  98.     </dependency>
  100.     <dependency>
  101.       <groupId>com.facebook.presto</groupId>
  102.       <artifactId>presto-main</artifactId>
  103.       <scope>test</scope>
  104.     </dependency>
  106.     <dependency>
  107.       <groupId>com.facebook.presto</groupId>
  108.       <artifactId>presto-tpch</artifactId>
  109.       <scope>test</scope>
  110.     </dependency>
  112.     <dependency>
  113.       <groupId>io.airlift.tpch</groupId>
  114.       <artifactId>tpch</artifactId>
  115.       <scope>test</scope>
  116.     </dependency>
  118.     <dependency>
  119.       <groupId>com.facebook.presto</groupId>
  120.       <artifactId>presto-tests</artifactId>
  121.       <scope>test</scope>
  122.     </dependency>
  124.     <dependency>
  125.       <groupId>io.airlift</groupId>
  126.       <artifactId>testing-mysql-server</artifactId>
  127.       <scope>test</scope>
  128.     </dependency>
  129.   </dependencies>
  131.   <build>
  133.     <plugins>
  134.       <plugin>
  135.         <groupId>org.apache.maven.plugins</groupId>
  136.         <artifactId>maven-dependency-plugin</artifactId>
  137.         <version>2.10</version>
  138.         <configuration>
  139.           <!--disable check dependency-->
  140.           <skip>true</skip>
  141.           <failOnWarning>${air.check.fail-dependency}</failOnWarning>
  142.           <ignoreNonCompile>true</ignoreNonCompile>
  143.         </configuration>
  144.       </plugin>
  146.       <plugin>
  147.         <groupId>org.apache.maven.plugins</groupId>
  148.         <artifactId>maven-checkstyle-plugin</artifactId>
  149.         <executions>
  150.           <execution>
  151.             <phase>validate</phase>
  152.             <goals>
  153.               <goal>check</goal>
  154.             </goals>
  155.             <configuration>
  156.               <!--disable check code style-->
  157.               <skip>true</skip>
  158.             </configuration>
  159.           </execution>
  160.         </executions>
  162.       </plugin>
  164.     </plugins>
  165.   </build>
  167. </project>

这里需要说明下的是 Maven 的公共库查找不到 Oracle JDBC 的依赖，所以需要用户自行下载 jar 包并安装到本地 Maven 库中。另外 Presto 有很严格的代码规范以及依赖检查，如果代码或者依赖不通过检查是无法编译成功的。而且公共 Maven 库中无法找到 Oracle JDBC 的依赖，所以依赖检查肯定不能通过。所以我在 pom 文件中禁用了代码规范检查插件，还有依赖检查插件。

1. 禁用依赖检查

  1. <plugin>
  2.   <groupId>org.apache.maven.plugins</groupId>
  3.   <artifactId>maven-dependency-plugin</artifactId>
  4.   <version>2.10</version>
  5.   <configuration>
  6.     <!--disable check dependency-->
  7.     <skip>true</skip>
  8.     <failOnWarning>${air.check.fail-dependency}</failOnWarning>
  9.     <ignoreNonCompile>true</ignoreNonCompile>
  10.   </configuration>
  11. </plugin>

2. 禁用代码规范检查

  1. <plugin>
  2.   <groupId>org.apache.maven.plugins</groupId>
  3.   <artifactId>maven-checkstyle-plugin</artifactId>
  4.   <executions>
  5.     <execution>
  6.       <phase>validate</phase>
  7.       <goals>
  8.         <goal>check</goal>
  9.       </goals>
  10.       <configuration>
  11.         <!--disable check code style-->
  12.         <skip>true</skip>
  13.       </configuration>
  14.     </execution>
  15.   </executions>
  16. </plugin>

3. 在 presto-root 下添加 ojdbc 的依赖信息

  1. <dependency>
  2.   <groupId>com.oracle</groupId>
  3.   <artifactId>ojdbc6</artifactId>
  4.   <version>11.2.0.4.0-atlassian-hosted</version>
  5. </dependency>

集成 module 到 Presto

因为我们是基于源码开发的，为了将 presto-oracle 集成到 Presto 中进行测试以及打包发布还需如下配置：

1.修改config.properties 配置文件

config.properties 文件在“presto/presto-main/etc”路径下，在plugin.bundles 下添加“../presto-oracle/pom.xml”。
Presto Oracle 插件编写教程 - 图1
只有添加了 presto-oracle 的 pom 信息 presto 在 IDE 中调试时再回加载 presto-oracle 插件，否则无效，上述配置只是用于开发环境，正式环境下无需配置。

2. 修改 presto.xml 配置文件 presto.xml 文件在“presto/presto-server/src/main/provisio”路径下，添加如下配置信息：

  1. <artifactSet to="plugin/oracle">
  2.   <artifact id="${project.groupId}:presto-oracle:zip:${project.version}">
  3.     <unpack />
  4.   </artifact>
  5. </artifactSet>

Presto Oracle 插件编写教程 - 图2
上述配置的作用是在 presto 编译时可以将我们的 presto-oracle 插件添加到 plugin 目录下。
Presto Oracle 插件编写教程 - 图3

编写代码

插件的代码就四个类，一点都不复杂，但是需要说明的是这些代码必须包含 license 信息，因为 presto 配置了证书的检查插件，如果代码中不包含license 编译时会报错。这个不像代码检查那么麻烦，代码检查有一点点不规范就会报错，这个证书检查只要在自己新建的类中添加 license 就即可通过。

1.OraclePlugin.java

  1. /*
  2. * Licensed under the Apache License, Version 2.0 (the "License");
  3. * you may not use this file except in compliance with the License.
  4. * You may obtain a copy of the License at
  5. *
  6. *     http://www.apache.org/licenses/LICENSE-2.0
  7. *
  8. * Unless required by applicable law or agreed to in writing, software
  9. * distributed under the License is distributed on an "AS IS" BASIS,
  10. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11. * See the License for the specific language governing permissions and
  12. * limitations under the License.
  13. */
  14. package com.facebook.presto.plugin.oracle;
  16. import com.facebook.presto.plugin.jdbc.JdbcPlugin;
  18. public class OraclePlugin
  19.     extends JdbcPlugin
  20. {
  21.   public OraclePlugin()
  22.   {
  23.       super("oracle", new OracleClientModule());
  24.   }
  25. }

上面构造函数中传入的”oracle” 应该是用于后面 catalog 中 name 的配置项，这个猜测没有验证，先这样配置。

2.OracleConfig.java

  1. /*
  2. * Licensed under the Apache License, Version 2.0 (the "License");
  3. * you may not use this file except in compliance with the License.
  4. * You may obtain a copy of the License at
  5. *
  6. *     http://www.apache.org/licenses/LICENSE-2.0
  7. *
  8. * Unless required by applicable law or agreed to in writing, software
  9. * distributed under the License is distributed on an "AS IS" BASIS,
  10. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11. * See the License for the specific language governing permissions and
  12. * limitations under the License.
  13. */
  14. package com.facebook.presto.plugin.oracle;
  16. import io.airlift.configuration.Config;
  18. public class OracleConfig {
  19.     private String user;
  20.     private String password;
  21.     private String url;
  23.     public String getUser() {
  24.         return user;
  25.     }
  27.     @Config("oracle.user")
  28.     public OracleConfig setUser(String user) {
  29.         this.user = user;
  30.         return this;
  31.     }
  33.     public String getPassword() {
  34.         return password;
  35.     }
  37.     @Config("oracle.password")
  38.     public OracleConfig setPassword(String password) {
  39.         this.password = password;
  40.         return this;
  41.     }
  43.     public String getUrl() {
  44.         return url;
  45.     }
  47.     @Config("oracle.password")
  48.     public OracleConfig setUrl(String url) {
  49.         this.url = url;
  50.         return this;
  51.     }
  52. }

上述代码中的注解千万不要省略掉，否则 presto 加载 catalog 时无法查找到这些属性。

3.OracleClientModule.java

  1. /*
  2.  * Licensed under the Apache License, Version 2.0 (the "License");
  3.  * you may not use this file except in compliance with the License.
  4.  * You may obtain a copy of the License at
  5.  *
  6.  *     http://www.apache.org/licenses/LICENSE-2.0
  7.  *
  8.  * Unless required by applicable law or agreed to in writing, software
  9.  * distributed under the License is distributed on an "AS IS" BASIS,
  10.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11.  * See the License for the specific language governing permissions and
  12.  * limitations under the License.
  13.  */
  14. package com.facebook.presto.plugin.oracle;
  16. import com.facebook.presto.plugin.jdbc.BaseJdbcConfig;
  17. import com.facebook.presto.plugin.jdbc.JdbcClient;
  18. import com.google.inject.Binder;
  19. import com.google.inject.Module;
  20. import com.google.inject.Scopes;
  22. import static io.airlift.configuration.ConfigBinder.configBinder;
  24. public class OracleClientModule
  25.     implements Module
  26. {
  27.     @Override
  28.     public void configure(Binder binder)
  29.     {
  30.         binder.bind(JdbcClient.class).to(OracleClient.class).in(Scopes.SINGLETON);
  31.         configBinder(binder).bindConfig(BaseJdbcConfig.class);
  32.         configBinder(binder).bindConfig(OracleConfig.class);
  33.     }
  34. }

4.OracleClient.java

  1. /*
  2. * Licensed under the Apache License, Version 2.0 (the "License");
  3. * you may not use this file except in compliance with the License.
  4. * You may obtain a copy of the License at
  5. *
  6. *     http://www.apache.org/licenses/LICENSE-2.0
  7. *
  8. * Unless required by applicable law or agreed to in writing, software
  9. * distributed under the License is distributed on an "AS IS" BASIS,
  10. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11. * See the License for the specific language governing permissions and
  12. * limitations under the License.
  13. */
  14. package com.facebook.presto.plugin.oracle;
  16. import com.facebook.presto.plugin.jdbc.*;
  17. import com.facebook.presto.spi.*;
  18. import com.facebook.presto.spi.type.Type;
  19. import com.google.common.base.Joiner;
  20. import com.google.common.base.Throwables;
  21. import com.google.common.collect.ImmutableList;
  22. import com.google.common.collect.ImmutableSet;
  23. import oracle.jdbc.OracleDriver;
  25. import javax.annotation.Nullable;
  26. import javax.inject.Inject;
  28. import java.sql.Connection;
  29. import java.sql.DatabaseMetaData;
  30. import java.sql.ResultSet;
  31. import java.sql.SQLException;
  32. import java.util.ArrayList;
  33. import java.util.List;
  34. import java.util.Set;
  35. import java.util.UUID;
  37. import static com.facebook.presto.plugin.jdbc.JdbcErrorCode.JDBC_ERROR;
  38. import static com.facebook.presto.spi.StandardErrorCode.NOT_FOUND;
  39. import static com.facebook.presto.spi.StandardErrorCode.NOT_SUPPORTED;
  40. import static com.google.common.collect.Iterables.getOnlyElement;
  41. import static com.google.common.collect.Maps.fromProperties;
  42. import static java.util.Locale.ENGLISH;
  44. public class OracleClient
  45.     extends BaseJdbcClient
  46. {
  47.   @Inject
  48.   public OracleClient(JdbcConnectorId connectorId, BaseJdbcConfig config, OracleConfig oracleConfig)
  49.           throws SQLException
  50.   {
  51.       super(connectorId, config, "", new OracleDriver());
  52.   }
  54.   @Override
  55.   public Set<String> getSchemaNames() {
  56.       try (Connection connection = driver.connect(connectionUrl,
  57.               connectionProperties);
  58.            ResultSet resultSet = connection.getMetaData().getSchemas()) {
  59.           ImmutableSet.Builder<String> schemaNames = ImmutableSet.builder();
  60.           while (resultSet.next()) {
  61.               String schemaName = resultSet.getString(1).toLowerCase();
  62.               schemaNames.add(schemaName);
  63.           }
  64.           return schemaNames.build();
  65.       } catch (SQLException e) {
  66.           throw Throwables.propagate(e);
  67.       }
  68.   }
  70.   @Override
  71.   protected ResultSet getTables(Connection connection, String schemaName, String tableName) throws SQLException {
  72.       return connection.getMetaData().getTables(null, schemaName, tableName,
  73.               new String[] { "TABLE", "SYNONYM" });
  74.   }
  76.   @Nullable
  77.   @Override
  78.   public JdbcTableHandle getTableHandle(SchemaTableName schemaTableName) {
  79.       try (Connection connection = driver.connect(connectionUrl,
  80.               connectionProperties)) {
  81.           DatabaseMetaData metadata = connection.getMetaData();
  82.           String jdbcSchemaName = schemaTableName.getSchemaName();
  83.           String jdbcTableName = schemaTableName.getTableName();
  84.           if (metadata.storesUpperCaseIdentifiers()) {
  85.               jdbcSchemaName = jdbcSchemaName.toUpperCase();
  86.               jdbcTableName = jdbcTableName.toUpperCase();
  87.           }
  88.           try (ResultSet resultSet = getTables(connection, jdbcSchemaName,
  89.                   jdbcTableName)) {
  90.               List<JdbcTableHandle> tableHandles = new ArrayList<>();
  91.               while (resultSet.next()) {
  92.                   tableHandles.add(new JdbcTableHandle(connectorId,
  93.                           schemaTableName, resultSet.getString("TABLE_CAT"),
  94.                           resultSet.getString("TABLE_SCHEM"), resultSet
  95.                           .getString("TABLE_NAME")));
  96.               }
  97.               if (tableHandles.isEmpty()) {
  98.                   return null;
  99.               }
  100.               if (tableHandles.size() > 1) {
  101.                   throw new PrestoException(NOT_SUPPORTED,
  102.                           "Multiple tables matched: " + schemaTableName);
  103.               }
  104.               return getOnlyElement(tableHandles);
  105.           }
  106.       } catch (SQLException e) {
  107.           throw Throwables.propagate(e);
  108.       }
  109.   }
  111.   @Override
  112.   public List<JdbcColumnHandle> getColumns(JdbcTableHandle tableHandle) {
  113.       try (Connection connection = driver.connect(connectionUrl,
  114.               connectionProperties)) {
  116.           ( (oracle.jdbc.driver.OracleConnection)connection ).setIncludeSynonyms(true);
  117.           DatabaseMetaData metadata = connection.getMetaData();
  118.           String schemaName = tableHandle.getSchemaName().toUpperCase();
  119.           String tableName = tableHandle.getTableName().toUpperCase();
  120.           try (ResultSet resultSet = metadata.getColumns(null, schemaName,
  121.                   tableName, null)) {
  122.               List<JdbcColumnHandle> columns = new ArrayList<>();
  123.               boolean found = false;
  124.               while (resultSet.next()) {
  125.                   found = true;
  126.                   Type columnType = toPrestoType(resultSet
  127.                           .getInt("DATA_TYPE"), resultSet.getInt("COLUMN_SIZE"));
  128.                   if (columnType != null) {
  129.                       String columnName = resultSet.getString("COLUMN_NAME");
  130.                       columns.add(new JdbcColumnHandle(connectorId,
  131.                               columnName, columnType));
  132.                   }
  133.               }
  134.               if (!found) {
  135.                   throw new TableNotFoundException(
  136.                           tableHandle.getSchemaTableName());
  137.               }
  138.               if (columns.isEmpty()) {
  139.                   throw new PrestoException(NOT_SUPPORTED,
  140.                           "Table has no supported column types: "
  141.                                   + tableHandle.getSchemaTableName());
  142.               }
  143.               return ImmutableList.copyOf(columns);
  144.           }
  145.       } catch (SQLException e) {
  146.           throw Throwables.propagate(e);
  147.       }
  148.   }
  150.   @Override
  151.   public List<SchemaTableName> getTableNames(@Nullable String schema) {
  152.       try (Connection connection = driver.connect(connectionUrl,
  153.               connectionProperties)) {
  154.           DatabaseMetaData metadata = connection.getMetaData();
  155.           if (metadata.storesUpperCaseIdentifiers() && (schema != null)) {
  156.               schema = schema.toUpperCase();
  157.           }
  158.           try (ResultSet resultSet = getTables(connection, schema, null)) {
  159.               ImmutableList.Builder<SchemaTableName> list = ImmutableList
  160.                       .builder();
  161.               while (resultSet.next()) {
  162.                   list.add(getSchemaTableName(resultSet));
  163.               }
  164.               return list.build();
  165.           }
  166.       } catch (SQLException e) {
  167.           throw Throwables.propagate(e);
  168.       }
  169.   }
  171.   @Override
  172.   protected SchemaTableName getSchemaTableName(ResultSet resultSet) throws SQLException {
  173.       String tableSchema = resultSet.getString("TABLE_SCHEM");
  174.       String tableName = resultSet.getString("TABLE_NAME");
  175.       if (tableSchema != null) {
  176.           tableSchema = tableSchema.toLowerCase();
  177.       }
  178.       if (tableName != null) {
  179.           tableName = tableName.toLowerCase();
  180.       }
  181.       return new SchemaTableName(tableSchema, tableName);
  182.   }
  184.   @Override
  185.   public void commitCreateTable(JdbcOutputTableHandle handle) {
  186.       StringBuilder sql = new StringBuilder()
  187.               .append("ALTER TABLE ")
  188.               .append(quoted(handle.getCatalogName(), handle.getSchemaName(), handle.getTemporaryTableName()))
  189.               .append(" RENAME TO ")
  190.               //new table name needn't to be with catalog and schema
  191.               .append(handle.getTableName());
  193.       try (Connection connection = getConnection(handle)) {
  194.           execute(connection, sql.toString());
  195.       }
  196.       catch (SQLException e) {
  197.           throw new PrestoException(JDBC_ERROR, e);
  198.       }
  199.   }
  201. }

上述代码中覆写了很多方法，主要是不同的数据库规则不一样，需要我们一一适配。之前提到过 github 中已经有人托管了presto-oracle的插件，但是这个插件没有适配好。例如我又覆写了commitCreateTable这个方法，主要是因为 oracle 中修改表名时新表名不需要再添加 schema ，否则会报错。

5.BaseJdbcClient.java

“BaseJdbcClient”是“OracleClient”的基类，它里面有一个方法涉及到创建临时表的方法，oracle 中表名有长度限制（30以内），所以我对表名进行了字符串的截取操作。

  1. private JdbcOutputTableHandle beginWriteTable(ConnectorTableMetadata tableMetadata)
  2. {
  3.     SchemaTableName schemaTableName = tableMetadata.getTable();
  4.     String schema = schemaTableName.getSchemaName();
  5.     String table = schemaTableName.getTableName();
  7.     if (!getSchemaNames().contains(schema)) {
  8.         throw new PrestoException(NOT_FOUND, "Schema not found: " + schema);
  9.     }
  11.     try (Connection connection = driver.connect(connectionUrl, connectionProperties)) {
  12.         boolean uppercase = connection.getMetaData().storesUpperCaseIdentifiers();
  13.         if (uppercase) {
  14.             schema = schema.toUpperCase(ENGLISH);
  15.             table = table.toUpperCase(ENGLISH);
  16.         }
  17.         String catalog = connection.getCatalog();
  19.         String temporaryName = "tmp_presto_" + UUID.randomUUID().toString().replace("-", "");
  20.         temporaryName = temporaryName.substring(0, 29);
  21.         StringBuilder sql = new StringBuilder()
  22.             .append("CREATE TABLE ")
  23.             .append(quoted(catalog, schema, temporaryName))
  24.             .append(" (");
  25.         ImmutableList.Builder<String> columnNames = ImmutableList.builder();
  26.         ImmutableList.Builder<Type> columnTypes = ImmutableList.builder();
  27.         ImmutableList.Builder<String> columnList = ImmutableList.builder();
  28.         for (ColumnMetadata column : tableMetadata.getColumns()) {
  29.             String columnName = column.getName();
  30.             if (uppercase) {
  31.                 columnName = columnName.toUpperCase(ENGLISH);
  32.             }
  33.             columnNames.add(columnName);
  34.             columnTypes.add(column.getType());
  35.             columnList.add(new StringBuilder()
  36.                            .append(quoted(columnName))
  37.                            .append(" ")
  38.                            .append(toSqlType(column.getType()))
  39.                            .toString());
  40.         }
  41.         Joiner.on(", ").appendTo(sql, columnList.build());
  42.         sql.append(")");
  44.         execute(connection, sql.toString());
  46.         return new JdbcOutputTableHandle(
  47.             connectorId,
  48.             catalog,
  49.             schema,
  50.             table,
  51.             columnNames.build(),
  52.             columnTypes.build(),
  53.             temporaryName,
  54.             connectionUrl,
  55.             fromProperties(connectionProperties));
  56.     }
  57.     catch (SQLException e) {
  58.         throw new PrestoException(JDBC_ERROR, e);
  59.     }
  60. }

编译打包

如果上述操作无误的话，重新编译 presto。编译成功之后会有 tar.gz 和 rpm 两种安装包。

1.tar.gz 文件

tar.gz 文件路径：presto/presto-srver/target
Presto Oracle 插件编写教程 - 图4

2.rpm 文件路径：presto/presto-server-rpm/target

Presto Oracle 插件编写教程 - 图5
如果上述操作出现问题，可以参照我托管的Presto，也可以留言与我共同探讨 。