This is an automated email from the ASF dual-hosted git repository.
hansva pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/hop.git
The following commit(s) were added to refs/heads/main by this push:
new e5b69973aa correctly read binary data, fixes #8207 (#8209)
e5b69973aa is described below
commit e5b69973aa2e3785767f500c39299ec7e441d0ea
Author: Hans Van Akelyen <[email protected]>
AuthorDate: Tue Sep 1 16:46:40 2026 +0200
correctly read binary data, fixes #8207 (#8209)
---
.../apache/hop/core/database/BaseDatabaseMeta.java | 9 +
.../org/apache/hop/core/database/Database.java | 23 +-
.../org/apache/hop/core/database/DatabaseMeta.java | 2 +
.../org/apache/hop/core/database/IDatabase.java | 11 +
.../apache/hop/core/row/value/ValueMetaBase.java | 45 +++-
.../core/database/BinaryValueRetrievalTest.java | 236 ++++++++++++++++++++
.../oracle/0008-binary-read-write.hpl | 197 +++++++++++++++++
.../oracle/main-0008-binary-column-types.hwf | 238 +++++++++++++++++++++
.../databases/cratedb/CrateDBDatabaseMetaTest.java | 1 -
.../apache/hop/databases/db2/DB2DatabaseMeta.java | 9 -
.../hop/databases/db2/DB2DatabaseMetaTest.java | 1 -
.../hop/databases/derby/DerbyDatabaseMeta.java | 5 -
.../hop/databases/derby/DerbyDatabaseMetaTest.java | 1 -
.../hop/databases/ingres/IngresDatabaseMeta.java | 5 -
.../databases/ingres/IngresDatabaseMetaTest.java | 1 -
.../databases/interbase/InterbaseDatabaseMeta.java | 5 -
.../interbase/InterbaseDatabaseMetaTest.java | 1 -
.../mssqlnative/MsSqlServerNativeDatabaseMeta.java | 5 -
.../postgresql/PostgreSqlDatabaseMeta.java | 5 -
.../postgresql/PostgreSqlDatabaseMetaTest.java | 1 -
.../vectorwise/VectorWiseDatabaseMeta.java | 5 -
.../vectorwise/VectorWiseDatabaseMetaTest.java | 3 -
.../hop/databases/vertica/VerticaDatabaseMeta.java | 8 -
.../databases/vertica/VerticaDatabaseMetaTest.java | 1 -
24 files changed, 730 insertions(+), 88 deletions(-)
diff --git
a/core/src/main/java/org/apache/hop/core/database/BaseDatabaseMeta.java
b/core/src/main/java/org/apache/hop/core/database/BaseDatabaseMeta.java
index cb91778bbd..2f4a5f338e 100644
--- a/core/src/main/java/org/apache/hop/core/database/BaseDatabaseMeta.java
+++ b/core/src/main/java/org/apache/hop/core/database/BaseDatabaseMeta.java
@@ -1123,7 +1123,16 @@ public abstract class BaseDatabaseMeta implements
Cloneable, IDatabase {
/**
* @return true if the database JDBC driver supports getBlob on the
resultset. If not we must use
* getBytes() to get the data.
+ * @deprecated The getter a binary column needs is decided by the JDBC type
the driver reports for
+ * that column, not by the connection: BLOB maps to {@code
java.sql.Blob} and BINARY,
+ * VARBINARY and LONGVARBINARY map to {@code byte[]}. A flag answered
once per connection
+ * could not tell those apart, so it fetched VARBINARY columns as Blobs
and drivers that
+ * follow the specification refused (issue #8207). It is no longer
consulted anywhere; a
+ * driver that genuinely cannot serve a Blob says so with a value
binding for {@link
+ * org.apache.hop.core.row.IValueMeta#TYPE_BINARY} in its own {@link
#getTypeRules()}. This
+ * method will be removed.
*/
+ @Deprecated(since = "2.20")
@Override
public boolean isSupportsGetBlob() {
return true;
diff --git a/core/src/main/java/org/apache/hop/core/database/Database.java
b/core/src/main/java/org/apache/hop/core/database/Database.java
index 8777edbd1d..cd3e758a25 100644
--- a/core/src/main/java/org/apache/hop/core/database/Database.java
+++ b/core/src/main/java/org/apache/hop/core/database/Database.java
@@ -22,7 +22,6 @@ import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.sql.BatchUpdateException;
-import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
@@ -4363,16 +4362,7 @@ public class Database implements IVariables,
ILoggingObject, AutoCloseable {
v = cstmt.getString(pos);
break;
case IValueMeta.TYPE_BINARY:
- if (databaseMeta.supportsGetBlob()) {
- Blob blob = cstmt.getBlob(pos);
- if (blob != null) {
- v = blob.getBytes(1L, (int) blob.length());
- } else {
- v = null;
- }
- } else {
- v = cstmt.getBytes(pos);
- }
+ v = cstmt.getBytes(pos);
break;
case IValueMeta.TYPE_DATE:
if (databaseMeta.supportsTimeStampToDateConversion()) {
@@ -4408,16 +4398,7 @@ public class Database implements IVariables,
ILoggingObject, AutoCloseable {
v = cstmt.getString(pos + i);
break;
case IValueMeta.TYPE_BINARY:
- if (databaseMeta.supportsGetBlob()) {
- Blob blob = cstmt.getBlob(pos + i);
- if (blob != null) {
- v = blob.getBytes(1L, (int) blob.length());
- } else {
- v = null;
- }
- } else {
- v = cstmt.getBytes(pos + i);
- }
+ v = cstmt.getBytes(pos + i);
break;
case IValueMeta.TYPE_DATE:
if (databaseMeta.supportsTimeStampToDateConversion()) {
diff --git a/core/src/main/java/org/apache/hop/core/database/DatabaseMeta.java
b/core/src/main/java/org/apache/hop/core/database/DatabaseMeta.java
index 442136fbf7..51c8903d14 100644
--- a/core/src/main/java/org/apache/hop/core/database/DatabaseMeta.java
+++ b/core/src/main/java/org/apache/hop/core/database/DatabaseMeta.java
@@ -1891,7 +1891,9 @@ public class DatabaseMeta extends HopMetadataBase
implements Cloneable, IHopMeta
/**
* @return true if the database JDBC driver supports getBlob on the
resultset. If not we must use
* getBytes() to get the data.
+ * @deprecated See {@link IDatabase#isSupportsGetBlob()}.
*/
+ @Deprecated(since = "2.20")
public boolean supportsGetBlob() {
return iDatabase.isSupportsGetBlob();
}
diff --git a/core/src/main/java/org/apache/hop/core/database/IDatabase.java
b/core/src/main/java/org/apache/hop/core/database/IDatabase.java
index 6f727a0220..542167c3a5 100644
--- a/core/src/main/java/org/apache/hop/core/database/IDatabase.java
+++ b/core/src/main/java/org/apache/hop/core/database/IDatabase.java
@@ -675,7 +675,18 @@ public interface IDatabase extends Cloneable {
/**
* @return true if the database JDBC driver supports getBlob on the
resultset. If not we must use
* getBytes() to get the data.
+ * @deprecated The getter a binary column needs is decided by the JDBC type
the driver reports for
+ * that column, not by the connection: BLOB maps to {@code
java.sql.Blob} and BINARY,
+ * VARBINARY and LONGVARBINARY map to {@code byte[]}. A flag answered
once per connection
+ * could not tell those apart, so it fetched VARBINARY columns as Blobs
and drivers that
+ * follow the specification refused (issue #8207). It is no longer
consulted anywhere: every
+ * dialect that answered it did so to work around that defect, DB2
included, whose stated
+ * reason turned out to be a misreading of it — a current DB2 driver
serves a real BLOB column
+ * through {@code getBlob()} without complaint. A driver that genuinely
cannot says so with a
+ * value binding for {@link
org.apache.hop.core.row.IValueMeta#TYPE_BINARY} in its own {@link
+ * #getTypeRules()}. No dialect Hop ships needs one. This method will be
removed.
*/
+ @Deprecated(since = "2.20")
boolean isSupportsGetBlob();
/**
diff --git
a/core/src/main/java/org/apache/hop/core/row/value/ValueMetaBase.java
b/core/src/main/java/org/apache/hop/core/row/value/ValueMetaBase.java
index 53df16d1d8..4bf25f1d03 100644
--- a/core/src/main/java/org/apache/hop/core/row/value/ValueMetaBase.java
+++ b/core/src/main/java/org/apache/hop/core/row/value/ValueMetaBase.java
@@ -5716,16 +5716,7 @@ public class ValueMetaBase implements IValueMeta {
}
break;
case IValueMeta.TYPE_BINARY:
- if (iDatabase.isSupportsGetBlob()) {
- Blob blob = resultSet.getBlob(index + 1);
- if (blob != null) {
- data = blob.getBytes(1L, (int) blob.length());
- } else {
- data = null;
- }
- } else {
- data = resultSet.getBytes(index + 1);
- }
+ data = getBinaryFromResultSet(resultSet, index + 1);
break;
case IValueMeta.TYPE_DATE:
@@ -5750,6 +5741,40 @@ public class ValueMetaBase implements IValueMeta {
}
}
+ /**
+ * Reads a binary column the way the JDBC specification defines it.
+ *
+ * <p>Hop has one binary value type, so BINARY, VARBINARY, LONGVARBINARY and
BLOB all arrive here
+ * as {@link IValueMeta#TYPE_BINARY} and the JDBC type they came from is the
only thing left that
+ * says how to fetch them. The specification maps BLOB to {@code
java.sql.Blob} and the other
+ * three to {@code byte[]}, so asking for a Blob is right for exactly one of
the four.
+ *
+ * <p>This used to be decided by {@code isSupportsGetBlob()}, a
per-connection flag, which meant a
+ * VARBINARY column was fetched as a Blob on every dialect that did not opt
out. Drivers that
+ * follow the specification refuse that conversion outright: SAP HANA
answers "Cannot convert SQL
+ * type VARBINARY to Java type java.sql.Blob" (issue #8207). A driver that
really cannot serve a
+ * Blob says so with a value binding of its own, which is consulted before
this method is ever
+ * reached. No dialect Hop ships needs one: DB2, the one dialect that
recorded a reason for the
+ * flag, was looking at this same defect, and a current DB2 driver serves a
real BLOB column
+ * without complaint.
+ *
+ * <p>An unknown original type means the value metadata did not come from a
result set, so there
+ * is nothing to say the column is a BLOB, and {@code getBytes()} is the
wider of the two getters.
+ *
+ * @param resultSet the result set to read from
+ * @param index the 1-based column index
+ */
+ private byte[] getBinaryFromResultSet(ResultSet resultSet, int index) throws
SQLException {
+ if (getOriginalColumnType() != Types.BLOB) {
+ return resultSet.getBytes(index);
+ }
+ Blob blob = resultSet.getBlob(index);
+ if (blob == null) {
+ return null;
+ }
+ return blob.getBytes(1L, (int) blob.length());
+ }
+
@Override
public void setPreparedStatementValue(
DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int
index, Object data)
diff --git
a/core/src/test/java/org/apache/hop/core/database/BinaryValueRetrievalTest.java
b/core/src/test/java/org/apache/hop/core/database/BinaryValueRetrievalTest.java
new file mode 100644
index 0000000000..10d815eee3
--- /dev/null
+++
b/core/src/test/java/org/apache/hop/core/database/BinaryValueRetrievalTest.java
@@ -0,0 +1,236 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hop.core.database;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.sql.Blob;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.List;
+import org.apache.hop.core.HopClientEnvironment;
+import org.apache.hop.core.database.types.DatabaseTypeRuleRegistry;
+import org.apache.hop.core.database.types.DatabaseTypes;
+import org.apache.hop.core.database.types.IDatabaseTypeRule;
+import org.apache.hop.core.database.types.IValueBinding;
+import org.apache.hop.core.exception.HopException;
+import org.apache.hop.core.row.IValueMeta;
+import org.apache.hop.core.row.value.ValueMetaBinary;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Which JDBC getter a binary column is read with.
+ *
+ * <p>Hop has one binary value type, so BINARY, VARBINARY, LONGVARBINARY and
BLOB all become {@link
+ * IValueMeta#TYPE_BINARY} and only the JDBC type the driver reported still
says how to fetch them.
+ * The specification maps BLOB to {@code java.sql.Blob} and the other three to
{@code byte[]}.
+ *
+ * <p>This used to be decided by {@code isSupportsGetBlob()}, one flag for the
whole connection,
+ * which fetched VARBINARY columns as Blobs on every dialect that did not opt
out. Issue #8207.
+ */
+class BinaryValueRetrievalTest {
+
+ private static final byte[] BYTES = {1, 2, 3};
+
+ /** A dialect with no opinion, which is what a Generic connection is. */
+ @DatabaseMetaPlugin(type = "BINARY_STANDARD", typeDescription = "Standard
binary dialect")
+ static class StandardDialect extends NoneDatabaseMeta {}
+
+ /** A dialect whose driver cannot serve a Blob, saying so the way DB2 does.
*/
+ @DatabaseMetaPlugin(type = "BINARY_AS_BYTES", typeDescription = "Bytes only
binary dialect")
+ static class BytesOnlyDialect extends NoneDatabaseMeta {
+ @Override
+ public List<IDatabaseTypeRule> getTypeRules() {
+ return DatabaseTypes.rules()
+ .bind(
+ IValueMeta.TYPE_BINARY,
+ new IValueBinding() {
+ @Override
+ public Object read(
+ IDatabase database, IValueMeta valueMeta, ResultSet
resultSet, int index)
+ throws SQLException {
+ return resultSet.getBytes(index);
+ }
+
+ @Override
+ public void write(
+ IDatabase database,
+ IValueMeta valueMeta,
+ PreparedStatement preparedStatement,
+ int index,
+ Object value) {
+ throw new UnsupportedOperationException("This binding only
reads values");
+ }
+ })
+ .build();
+ }
+ }
+
+ /** A dialect that has not migrated and still answers the deprecated flag. */
+ @DatabaseMetaPlugin(type = "BINARY_LEGACY_FLAG", typeDescription = "Legacy
flag dialect")
+ static class LegacyFlagDialect extends NoneDatabaseMeta {
+ @Override
+ @Deprecated(since = "2.20")
+ public boolean isSupportsGetBlob() {
+ return false;
+ }
+ }
+
+ @BeforeAll
+ static void setUpClass() throws HopException {
+ HopClientEnvironment.init();
+ }
+
+ @BeforeEach
+ void setUp() {
+ // Binding rules are cached per dialect class.
+ DatabaseTypeRuleRegistry.clearCache();
+ }
+
+ private static IValueMeta binaryColumn(int originalColumnType) {
+ IValueMeta valueMeta = new ValueMetaBinary("b");
+ valueMeta.setOriginalColumnType(originalColumnType);
+ return valueMeta;
+ }
+
+ /** A result set whose driver refuses the Blob conversion, the way SAP
HANA's does. */
+ private static ResultSet resultSetRefusingBlob() throws SQLException {
+ ResultSet resultSet = mock(ResultSet.class);
+ when(resultSet.getBytes(1)).thenReturn(BYTES);
+ when(resultSet.getBlob(anyInt()))
+ .thenThrow(
+ new SQLException("Cannot convert SQL type VARBINARY to Java type
java.sql.Blob"));
+ return resultSet;
+ }
+
+ private static ResultSet resultSetServingBlob() throws SQLException {
+ ResultSet resultSet = mock(ResultSet.class);
+ Blob blob = mock(Blob.class);
+ when(blob.length()).thenReturn((long) BYTES.length);
+ when(blob.getBytes(1L, BYTES.length)).thenReturn(BYTES);
+ when(resultSet.getBlob(1)).thenReturn(blob);
+ when(resultSet.getBytes(1)).thenReturn(BYTES);
+ return resultSet;
+ }
+
+ @Test
+ void aVarbinaryColumnIsReadAsBytes() throws Exception {
+ ResultSet resultSet = resultSetRefusingBlob();
+
+ Object value =
+ new StandardDialect().getValueFromResultSet(resultSet,
binaryColumn(Types.VARBINARY), 0);
+
+ assertArrayEquals(BYTES, (byte[]) value);
+ verify(resultSet, never()).getBlob(anyInt());
+ }
+
+ @Test
+ void aBinaryColumnIsReadAsBytes() throws Exception {
+ ResultSet resultSet = resultSetRefusingBlob();
+
+ Object value =
+ new StandardDialect().getValueFromResultSet(resultSet,
binaryColumn(Types.BINARY), 0);
+
+ assertArrayEquals(BYTES, (byte[]) value);
+ verify(resultSet, never()).getBlob(anyInt());
+ }
+
+ @Test
+ void aLongVarbinaryColumnIsReadAsBytes() throws Exception {
+ ResultSet resultSet = resultSetRefusingBlob();
+
+ Object value =
+ new StandardDialect()
+ .getValueFromResultSet(resultSet,
binaryColumn(Types.LONGVARBINARY), 0);
+
+ assertArrayEquals(BYTES, (byte[]) value);
+ verify(resultSet, never()).getBlob(anyInt());
+ }
+
+ @Test
+ void aBlobColumnIsReadAsABlob() throws Exception {
+ ResultSet resultSet = resultSetServingBlob();
+
+ Object value =
+ new StandardDialect().getValueFromResultSet(resultSet,
binaryColumn(Types.BLOB), 0);
+
+ assertArrayEquals(BYTES, (byte[]) value);
+ verify(resultSet).getBlob(1);
+ verify(resultSet, never()).getBytes(anyInt());
+ }
+
+ @Test
+ void aNullBlobReadsAsNull() throws Exception {
+ ResultSet resultSet = mock(ResultSet.class);
+ when(resultSet.getBlob(1)).thenReturn(null);
+
+ assertNull(new StandardDialect().getValueFromResultSet(resultSet,
binaryColumn(Types.BLOB), 0));
+ }
+
+ /**
+ * A value meta that did not come from a result set has no JDBC type to go
on, so nothing says the
+ * column is a BLOB and the wider of the two getters is used.
+ */
+ @Test
+ void aColumnOfUnknownJdbcTypeIsReadAsBytes() throws Exception {
+ ResultSet resultSet = resultSetRefusingBlob();
+
+ Object value =
+ new StandardDialect().getValueFromResultSet(resultSet, new
ValueMetaBinary("b"), 0);
+
+ assertArrayEquals(BYTES, (byte[]) value);
+ verify(resultSet, never()).getBlob(anyInt());
+ }
+
+ @Test
+ void aDialectDeclaringBinaryAsBytesReadsEvenABlobColumnAsBytes() throws
Exception {
+ ResultSet resultSet = resultSetServingBlob();
+
+ Object value =
+ new BytesOnlyDialect().getValueFromResultSet(resultSet,
binaryColumn(Types.BLOB), 0);
+
+ assertArrayEquals(BYTES, (byte[]) value);
+ verify(resultSet, never()).getBlob(anyInt());
+ }
+
+ /**
+ * The deprecated flag is not consulted. Every dialect that answered it was
working around the
+ * defect above rather than a driver that cannot serve a Blob, so honouring
it would keep them on
+ * the wrong getter; one that really needs bytes declares a binding, as
above.
+ */
+ @Test
+ void theDeprecatedFlagIsIgnored() throws Exception {
+ ResultSet resultSet = resultSetServingBlob();
+
+ Object value =
+ new LegacyFlagDialect().getValueFromResultSet(resultSet,
binaryColumn(Types.BLOB), 0);
+
+ assertArrayEquals(BYTES, (byte[]) value);
+ verify(resultSet).getBlob(1);
+ verify(resultSet, never()).getBytes(anyInt());
+ }
+}
diff --git a/integration-tests/oracle/0008-binary-read-write.hpl
b/integration-tests/oracle/0008-binary-read-write.hpl
new file mode 100644
index 0000000000..5b3f108715
--- /dev/null
+++ b/integration-tests/oracle/0008-binary-read-write.hpl
@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-->
+<pipeline>
+ <info>
+ <name>0008-binary-read-write</name>
+ <name_sync_with_filename>Y</name_sync_with_filename>
+ <description>Reads Oracle's three binary column shapes and writes them
straight back out, so that a wrong JDBC getter shows up as a wrong value rather
than as a silent success. BLOB is read as bytes through java.sql.Blob; RAW and
LONG RAW arrive as VARBINARY and LONGVARBINARY but are Oracle's text-shaped
binaries, so Hop reads them as hex strings.</description>
+ <extended_description/>
+ <pipeline_version/>
+ <pipeline_type>Normal</pipeline_type>
+ <parameters>
+ </parameters>
+ <capture_transform_performance>N</capture_transform_performance>
+
<transform_performance_capturing_delay>1000</transform_performance_capturing_delay>
+
<transform_performance_capturing_size_limit>100</transform_performance_capturing_size_limit>
+ <created_user>-</created_user>
+ <created_date>2026/09/01 12:00:00.000</created_date>
+ <modified_user>-</modified_user>
+ <modified_date>2026/09/01 12:00:00.000</modified_date>
+ </info>
+ <notepads>
+ </notepads>
+ <order>
+ <hop>
+ <from>BLOB and RAW in</from>
+ <to>BLOB and RAW out</to>
+ <enabled>Y</enabled>
+ </hop>
+ <hop>
+ <from>LONG RAW in</from>
+ <to>LONG RAW out</to>
+ <enabled>Y</enabled>
+ </hop>
+ </order>
+ <transform>
+ <name>BLOB and RAW in</name>
+ <type>TableInput</type>
+ <description>A BLOB column is the one binary shape Oracle really does hand
over as a java.sql.Blob.</description>
+ <distribute>Y</distribute>
+ <custom_distribution/>
+ <copies>1</copies>
+ <partitioning>
+ <method>none</method>
+ <schema_name/>
+ </partitioning>
+ <connection>oracle-service-name</connection>
+ <execute_each_row>N</execute_each_row>
+ <limit>0</limit>
+ <sql>SELECT ID, C_BLOB, C_RAW
+FROM HOP_BINARY_SOURCE
+ORDER BY ID</sql>
+ <variables_active>N</variables_active>
+ <attributes/>
+ <GUI>
+ <xloc>144</xloc>
+ <yloc>112</yloc>
+ </GUI>
+ </transform>
+ <transform>
+ <name>BLOB and RAW out</name>
+ <type>TableOutput</type>
+ <description/>
+ <distribute>Y</distribute>
+ <custom_distribution/>
+ <copies>1</copies>
+ <partitioning>
+ <method>none</method>
+ <schema_name/>
+ </partitioning>
+ <commit>1000</commit>
+ <connection>oracle-service-name</connection>
+ <fields>
+ <field>
+ <column_name>ID</column_name>
+ <stream_name>ID</stream_name>
+ </field>
+ <field>
+ <column_name>T_BLOB</column_name>
+ <stream_name>C_BLOB</stream_name>
+ </field>
+ <field>
+ <column_name>T_RAW</column_name>
+ <stream_name>C_RAW</stream_name>
+ </field>
+ </fields>
+ <ignore_errors>N</ignore_errors>
+ <only_when_have_rows>N</only_when_have_rows>
+ <partitioning_daily>N</partitioning_daily>
+ <partitioning_enabled>N</partitioning_enabled>
+ <partitioning_field/>
+ <partitioning_monthly>Y</partitioning_monthly>
+ <return_field/>
+ <return_keys>N</return_keys>
+ <schema/>
+ <specify_fields>Y</specify_fields>
+ <table>HOP_BINARY_TARGET</table>
+ <tablename_field/>
+ <tablename_in_field>N</tablename_in_field>
+ <tablename_in_table>Y</tablename_in_table>
+ <truncate>N</truncate>
+ <use_batch>Y</use_batch>
+ <attributes/>
+ <GUI>
+ <xloc>384</xloc>
+ <yloc>112</yloc>
+ </GUI>
+ </transform>
+ <transform>
+ <name>LONG RAW in</name>
+ <type>TableInput</type>
+ <description>LONG RAW is a streaming column and only one is allowed per
table, so it gets its own.</description>
+ <distribute>Y</distribute>
+ <custom_distribution/>
+ <copies>1</copies>
+ <partitioning>
+ <method>none</method>
+ <schema_name/>
+ </partitioning>
+ <connection>oracle-service-name</connection>
+ <execute_each_row>N</execute_each_row>
+ <limit>0</limit>
+ <sql>SELECT ID, C_LONGRAW
+FROM HOP_BINARY_LONG_SOURCE
+ORDER BY ID</sql>
+ <variables_active>N</variables_active>
+ <attributes/>
+ <GUI>
+ <xloc>144</xloc>
+ <yloc>240</yloc>
+ </GUI>
+ </transform>
+ <transform>
+ <name>LONG RAW out</name>
+ <type>TableOutput</type>
+ <description/>
+ <distribute>Y</distribute>
+ <custom_distribution/>
+ <copies>1</copies>
+ <partitioning>
+ <method>none</method>
+ <schema_name/>
+ </partitioning>
+ <commit>1000</commit>
+ <connection>oracle-service-name</connection>
+ <fields>
+ <field>
+ <column_name>ID</column_name>
+ <stream_name>ID</stream_name>
+ </field>
+ <field>
+ <column_name>T_LONGRAW</column_name>
+ <stream_name>C_LONGRAW</stream_name>
+ </field>
+ </fields>
+ <ignore_errors>N</ignore_errors>
+ <only_when_have_rows>N</only_when_have_rows>
+ <partitioning_daily>N</partitioning_daily>
+ <partitioning_enabled>N</partitioning_enabled>
+ <partitioning_field/>
+ <partitioning_monthly>Y</partitioning_monthly>
+ <return_field/>
+ <return_keys>N</return_keys>
+ <schema/>
+ <specify_fields>Y</specify_fields>
+ <table>HOP_BINARY_LONG_TARGET</table>
+ <tablename_field/>
+ <tablename_in_field>N</tablename_in_field>
+ <tablename_in_table>Y</tablename_in_table>
+ <truncate>N</truncate>
+ <use_batch>Y</use_batch>
+ <attributes/>
+ <GUI>
+ <xloc>384</xloc>
+ <yloc>240</yloc>
+ </GUI>
+ </transform>
+ <transform_error_handling>
+ </transform_error_handling>
+ <attributes/>
+</pipeline>
diff --git a/integration-tests/oracle/main-0008-binary-column-types.hwf
b/integration-tests/oracle/main-0008-binary-column-types.hwf
new file mode 100644
index 0000000000..8ecb3513cc
--- /dev/null
+++ b/integration-tests/oracle/main-0008-binary-column-types.hwf
@@ -0,0 +1,238 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-->
+<workflow>
+ <name>main-0008-binary-column-types</name>
+ <name_sync_with_filename>Y</name_sync_with_filename>
+ <description>Oracle's three binary column shapes, read out and written
straight back. Hop has one binary value type, so BLOB, RAW and LONG RAW all
lose the JDBC type they came from unless something keeps it; the getter is
chosen from that type, and choosing wrongly is issue #8207. Oracle is the
database the original always-use-getBlob handling was written for in 2006,
which is why it is guarded here: getBlob works on its BLOB columns and fails on
its RAW and LONG RAW ones.</description>
+ <extended_description/>
+ <workflow_version/>
+ <created_user>-</created_user>
+ <created_date>2026/09/01 12:00:00.000</created_date>
+ <modified_user>-</modified_user>
+ <modified_date>2026/09/01 12:00:00.000</modified_date>
+ <parameters>
+ </parameters>
+ <actions>
+ <action>
+ <name>Start</name>
+ <description/>
+ <type>SPECIAL</type>
+ <attributes/>
+ <DayOfMonth>1</DayOfMonth>
+ <hour>12</hour>
+ <intervalMinutes>60</intervalMinutes>
+ <intervalSeconds>0</intervalSeconds>
+ <minutes>0</minutes>
+ <repeat>N</repeat>
+ <schedulerType>0</schedulerType>
+ <weekDay>1</weekDay>
+ <parallel>N</parallel>
+ <xloc>50</xloc>
+ <yloc>50</yloc>
+ <attributes_hac/>
+ </action>
+ <action>
+ <name>Init tables</name>
+ <description/>
+ <type>SQL</type>
+ <attributes/>
+ <sql>DECLARE
+ table_missing EXCEPTION;
+ PRAGMA EXCEPTION_INIT(table_missing, -942);
+ PROCEDURE drop_if_present(name VARCHAR2) IS
+ BEGIN
+ EXECUTE IMMEDIATE 'DROP TABLE ' || name;
+ EXCEPTION
+ WHEN table_missing THEN NULL;
+ END;
+BEGIN
+ drop_if_present('HOP_BINARY_SOURCE');
+ drop_if_present('HOP_BINARY_TARGET');
+ drop_if_present('HOP_BINARY_LONG_SOURCE');
+ drop_if_present('HOP_BINARY_LONG_TARGET');
+
+ EXECUTE IMMEDIATE 'CREATE TABLE HOP_BINARY_SOURCE (
+ ID NUMBER(10),
+ C_BLOB BLOB,
+ C_RAW RAW(20))';
+
+ EXECUTE IMMEDIATE 'CREATE TABLE HOP_BINARY_TARGET (
+ ID NUMBER(10),
+ T_BLOB BLOB,
+ T_RAW VARCHAR2(64))';
+
+ -- Only one LONG RAW column is allowed per table, so it gets one of its own.
+ EXECUTE IMMEDIATE 'CREATE TABLE HOP_BINARY_LONG_SOURCE (
+ ID NUMBER(10),
+ C_LONGRAW LONG RAW)';
+
+ EXECUTE IMMEDIATE 'CREATE TABLE HOP_BINARY_LONG_TARGET (
+ ID NUMBER(10),
+ T_LONGRAW VARCHAR2(64))';
+
+ EXECUTE IMMEDIATE 'INSERT INTO HOP_BINARY_SOURCE
+ VALUES (1, HEXTORAW(''DEADBEEF01''), HEXTORAW(''0102030405''))';
+ EXECUTE IMMEDIATE 'INSERT INTO HOP_BINARY_SOURCE VALUES (2, NULL, NULL)';
+
+ EXECUTE IMMEDIATE 'INSERT INTO HOP_BINARY_LONG_SOURCE
+ VALUES (1, HEXTORAW(''CAFEBABE02''))';
+ EXECUTE IMMEDIATE 'INSERT INTO HOP_BINARY_LONG_SOURCE VALUES (2, NULL)';
+ COMMIT;
+END;</sql>
+ <useVariableSubstitution>F</useVariableSubstitution>
+ <sqlfromfile>F</sqlfromfile>
+ <sqlfilename/>
+ <sendOneStatement>T</sendOneStatement>
+ <connection>oracle-service-name</connection>
+ <parallel>N</parallel>
+ <xloc>224</xloc>
+ <yloc>48</yloc>
+ <attributes_hac/>
+ </action>
+ <action>
+ <name>0008-binary-read-write.hpl</name>
+ <description/>
+ <type>PIPELINE</type>
+ <attributes/>
+ <add_date>N</add_date>
+ <add_time>N</add_time>
+ <clear_files>N</clear_files>
+ <clear_rows>N</clear_rows>
+ <create_parent_folder>N</create_parent_folder>
+ <exec_per_row>N</exec_per_row>
+ <filename>${PROJECT_HOME}/0008-binary-read-write.hpl</filename>
+ <logext/>
+ <logfile/>
+ <loglevel>Basic</loglevel>
+ <parameters>
+ <pass_all_parameters>Y</pass_all_parameters>
+ </parameters>
+ <params_from_previous>N</params_from_previous>
+ <run_configuration>local</run_configuration>
+ <set_append_logfile>N</set_append_logfile>
+ <set_logfile>N</set_logfile>
+ <wait_until_finished>Y</wait_until_finished>
+ <parallel>N</parallel>
+ <xloc>432</xloc>
+ <yloc>48</yloc>
+ <attributes_hac/>
+ </action>
+ <action>
+ <name>check what was read</name>
+ <description/>
+ <type>SQL</type>
+ <attributes/>
+ <sql>DECLARE
+ found NUMBER;
+BEGIN
+ SELECT COUNT(*) INTO found FROM HOP_BINARY_TARGET;
+ IF found <> 2 THEN
+ RAISE_APPLICATION_ERROR(-20080, 'expected 2 BLOB/RAW rows but found ' ||
found);
+ END IF;
+
+ SELECT COUNT(*) INTO found FROM HOP_BINARY_LONG_TARGET;
+ IF found <> 2 THEN
+ RAISE_APPLICATION_ERROR(-20081, 'expected 2 LONG RAW rows but found ' ||
found);
+ END IF;
+
+ -- A BLOB is the one shape Oracle serves as a java.sql.Blob. Reading it as
bytes instead
+ -- would still succeed on a modern driver, so this compares the content
rather than trusting
+ -- that the read did not throw.
+ SELECT COUNT(*) INTO found
+ FROM HOP_BINARY_TARGET t
+ JOIN HOP_BINARY_SOURCE s ON s.ID = t.ID
+ WHERE t.ID = 1
+ AND DBMS_LOB.COMPARE(t.T_BLOB, s.C_BLOB) = 0;
+ IF found <> 1 THEN
+ RAISE_APPLICATION_ERROR(-20082, 'the BLOB value did not survive the round
trip');
+ END IF;
+
+ -- RAW and LONG RAW are reported as VARBINARY and LONGVARBINARY. Asking
either of them for a
+ -- Blob fails outright with ORA-17004, so Hop reads them as the hex text
Oracle gives back.
+ SELECT COUNT(*) INTO found
+ FROM HOP_BINARY_TARGET t
+ JOIN HOP_BINARY_SOURCE s ON s.ID = t.ID
+ WHERE t.ID = 1
+ AND t.T_RAW = RAWTOHEX(s.C_RAW);
+ IF found <> 1 THEN
+ RAISE_APPLICATION_ERROR(-20083, 'the RAW value did not survive the round
trip');
+ END IF;
+
+ SELECT COUNT(*) INTO found
+ FROM HOP_BINARY_LONG_TARGET
+ WHERE ID = 1
+ AND T_LONGRAW = 'CAFEBABE02';
+ IF found <> 1 THEN
+ RAISE_APPLICATION_ERROR(-20084, 'the LONG RAW value did not survive the
round trip');
+ END IF;
+
+ -- A null binary column must read back as null, not as an empty value.
+ SELECT COUNT(*) INTO found
+ FROM HOP_BINARY_TARGET
+ WHERE ID = 2 AND T_BLOB IS NULL AND T_RAW IS NULL;
+ IF found <> 1 THEN
+ RAISE_APPLICATION_ERROR(-20085, 'the null BLOB and RAW row did not survive
the round trip');
+ END IF;
+
+ SELECT COUNT(*) INTO found
+ FROM HOP_BINARY_LONG_TARGET
+ WHERE ID = 2 AND T_LONGRAW IS NULL;
+ IF found <> 1 THEN
+ RAISE_APPLICATION_ERROR(-20086, 'the null LONG RAW row did not survive the
round trip');
+ END IF;
+END;</sql>
+ <useVariableSubstitution>F</useVariableSubstitution>
+ <sqlfromfile>F</sqlfromfile>
+ <sqlfilename/>
+ <sendOneStatement>T</sendOneStatement>
+ <connection>oracle-service-name</connection>
+ <parallel>N</parallel>
+ <xloc>688</xloc>
+ <yloc>48</yloc>
+ <attributes_hac/>
+ </action>
+ </actions>
+ <hops>
+ <hop>
+ <from>Start</from>
+ <to>Init tables</to>
+ <enabled>Y</enabled>
+ <evaluation>Y</evaluation>
+ <unconditional>Y</unconditional>
+ </hop>
+ <hop>
+ <from>Init tables</from>
+ <to>0008-binary-read-write.hpl</to>
+ <enabled>Y</enabled>
+ <evaluation>Y</evaluation>
+ <unconditional>N</unconditional>
+ </hop>
+ <hop>
+ <from>0008-binary-read-write.hpl</from>
+ <to>check what was read</to>
+ <enabled>Y</enabled>
+ <evaluation>Y</evaluation>
+ <unconditional>N</unconditional>
+ </hop>
+ </hops>
+ <notepads>
+ </notepads>
+ <attributes/>
+</workflow>
diff --git
a/plugins/databases/cratedb/src/test/java/org/apache/hop/databases/cratedb/CrateDBDatabaseMetaTest.java
b/plugins/databases/cratedb/src/test/java/org/apache/hop/databases/cratedb/CrateDBDatabaseMetaTest.java
index 1bb7c24679..060d054f9e 100644
---
a/plugins/databases/cratedb/src/test/java/org/apache/hop/databases/cratedb/CrateDBDatabaseMetaTest.java
+++
b/plugins/databases/cratedb/src/test/java/org/apache/hop/databases/cratedb/CrateDBDatabaseMetaTest.java
@@ -168,7 +168,6 @@ class CrateDBDatabaseMetaTest {
nativeMeta.getExtraOptionsHelpText());
assertFalse(nativeMeta.IsSupportsErrorHandlingOnBatchUpdates());
assertTrue(nativeMeta.isRequiresCastToVariousForIsNull());
- assertFalse(nativeMeta.isSupportsGetBlob());
assertTrue(nativeMeta.isUseSafePoints());
assertTrue(nativeMeta.isSupportsBooleanDataType());
assertTrue(nativeMeta.isSupportsTimestampDataType());
diff --git
a/plugins/databases/db2/src/main/java/org/apache/hop/databases/db2/DB2DatabaseMeta.java
b/plugins/databases/db2/src/main/java/org/apache/hop/databases/db2/DB2DatabaseMeta.java
index 650866139a..533fa0bd4b 100644
---
a/plugins/databases/db2/src/main/java/org/apache/hop/databases/db2/DB2DatabaseMeta.java
+++
b/plugins/databases/db2/src/main/java/org/apache/hop/databases/db2/DB2DatabaseMeta.java
@@ -748,15 +748,6 @@ public class DB2DatabaseMeta extends BaseDatabaseMeta
implements IDatabase {
return true;
}
- /**
- * @return false because the DB2 JDBC driver doesn't support getBlob on the
resultset. We must use
- * getBytes() to get the data.
- */
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
-
/**
* @return true if the database supports sequences
*/
diff --git
a/plugins/databases/db2/src/test/java/org/apache/hop/databases/db2/DB2DatabaseMetaTest.java
b/plugins/databases/db2/src/test/java/org/apache/hop/databases/db2/DB2DatabaseMetaTest.java
index 44c25ac96e..e81f4dba73 100644
---
a/plugins/databases/db2/src/test/java/org/apache/hop/databases/db2/DB2DatabaseMetaTest.java
+++
b/plugins/databases/db2/src/test/java/org/apache/hop/databases/db2/DB2DatabaseMetaTest.java
@@ -515,7 +515,6 @@ class DB2DatabaseMetaTest {
assertEquals(32672, nativeMeta.getMaxVARCHARLength());
assertTrue(nativeMeta.isSupportsBatchUpdates());
- assertFalse(nativeMeta.isSupportsGetBlob());
assertTrue(nativeMeta.isSupportsSequences());
assertEquals(":", nativeMeta.getExtraOptionIndicator());
assertFalse(nativeMeta.isSupportsSequenceNoMaxValueOption());
diff --git
a/plugins/databases/derby/src/main/java/org/apache/hop/databases/derby/DerbyDatabaseMeta.java
b/plugins/databases/derby/src/main/java/org/apache/hop/databases/derby/DerbyDatabaseMeta.java
index 1fb2410ca2..a8ab5a9f9b 100644
---
a/plugins/databases/derby/src/main/java/org/apache/hop/databases/derby/DerbyDatabaseMeta.java
+++
b/plugins/databases/derby/src/main/java/org/apache/hop/databases/derby/DerbyDatabaseMeta.java
@@ -254,11 +254,6 @@ public class DerbyDatabaseMeta extends BaseDatabaseMeta
implements IDatabase {
return 1527;
}
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
-
@Override
public String getExtraOptionsHelpText() {
return "http://db.apache.org/derby/papers/DerbyClientSpec.html";;
diff --git
a/plugins/databases/derby/src/test/java/org/apache/hop/databases/derby/DerbyDatabaseMetaTest.java
b/plugins/databases/derby/src/test/java/org/apache/hop/databases/derby/DerbyDatabaseMetaTest.java
index 449090060d..2d42e20e9a 100644
---
a/plugins/databases/derby/src/test/java/org/apache/hop/databases/derby/DerbyDatabaseMetaTest.java
+++
b/plugins/databases/derby/src/test/java/org/apache/hop/databases/derby/DerbyDatabaseMetaTest.java
@@ -60,7 +60,6 @@ class DerbyDatabaseMetaTest {
assertTrue(nativeMeta.isFetchSizeSupported());
assertFalse(nativeMeta.isSupportsBitmapIndex());
assertEquals(1527, nativeMeta.getDefaultDatabasePort());
- assertFalse(nativeMeta.isSupportsGetBlob());
assertEquals(
"http://db.apache.org/derby/papers/DerbyClientSpec.html";,
nativeMeta.getExtraOptionsHelpText());
diff --git
a/plugins/databases/ingres/src/main/java/org/apache/hop/databases/ingres/IngresDatabaseMeta.java
b/plugins/databases/ingres/src/main/java/org/apache/hop/databases/ingres/IngresDatabaseMeta.java
index b2471b985b..353304e5d0 100644
---
a/plugins/databases/ingres/src/main/java/org/apache/hop/databases/ingres/IngresDatabaseMeta.java
+++
b/plugins/databases/ingres/src/main/java/org/apache/hop/databases/ingres/IngresDatabaseMeta.java
@@ -240,9 +240,4 @@ public class IngresDatabaseMeta extends BaseDatabaseMeta
implements IDatabase {
public String getTruncateTableStatement(String tableName) {
return "DELETE FROM " + tableName;
}
-
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
}
diff --git
a/plugins/databases/ingres/src/test/java/org/apache/hop/databases/ingres/IngresDatabaseMetaTest.java
b/plugins/databases/ingres/src/test/java/org/apache/hop/databases/ingres/IngresDatabaseMetaTest.java
index 6b3fc5693c..12eb8cc7ab 100644
---
a/plugins/databases/ingres/src/test/java/org/apache/hop/databases/ingres/IngresDatabaseMetaTest.java
+++
b/plugins/databases/ingres/src/test/java/org/apache/hop/databases/ingres/IngresDatabaseMetaTest.java
@@ -59,7 +59,6 @@ class IngresDatabaseMetaTest {
assertTrue(nativeMeta.isFetchSizeSupported());
assertFalse(nativeMeta.isSupportsBitmapIndex());
assertFalse(nativeMeta.isSupportsSynonyms());
- assertFalse(nativeMeta.isSupportsGetBlob());
}
@Test
diff --git
a/plugins/databases/interbase/src/main/java/org/apache/hop/databases/interbase/InterbaseDatabaseMeta.java
b/plugins/databases/interbase/src/main/java/org/apache/hop/databases/interbase/InterbaseDatabaseMeta.java
index 7d3378b45e..cd14d17eae 100644
---
a/plugins/databases/interbase/src/main/java/org/apache/hop/databases/interbase/InterbaseDatabaseMeta.java
+++
b/plugins/databases/interbase/src/main/java/org/apache/hop/databases/interbase/InterbaseDatabaseMeta.java
@@ -940,9 +940,4 @@ public class InterbaseDatabaseMeta extends BaseDatabaseMeta
implements IDatabase
public boolean isSupportsBatchUpdates() {
return false;
}
-
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
}
diff --git
a/plugins/databases/interbase/src/test/java/org/apache/hop/databases/interbase/InterbaseDatabaseMetaTest.java
b/plugins/databases/interbase/src/test/java/org/apache/hop/databases/interbase/InterbaseDatabaseMetaTest.java
index 21fb194b8d..6caec8fc2e 100644
---
a/plugins/databases/interbase/src/test/java/org/apache/hop/databases/interbase/InterbaseDatabaseMetaTest.java
+++
b/plugins/databases/interbase/src/test/java/org/apache/hop/databases/interbase/InterbaseDatabaseMetaTest.java
@@ -748,7 +748,6 @@ class InterbaseDatabaseMetaTest {
nativeMeta.getReservedWords());
assertFalse(nativeMeta.isSupportsTimeStampToDateConversion());
assertFalse(nativeMeta.isSupportsBatchUpdates());
- assertFalse(nativeMeta.isSupportsGetBlob());
}
@Test
diff --git
a/plugins/databases/mssqlnative/src/main/java/org/apache/hop/databases/mssqlnative/MsSqlServerNativeDatabaseMeta.java
b/plugins/databases/mssqlnative/src/main/java/org/apache/hop/databases/mssqlnative/MsSqlServerNativeDatabaseMeta.java
index b7e4ae564d..0ac37c60f7 100644
---
a/plugins/databases/mssqlnative/src/main/java/org/apache/hop/databases/mssqlnative/MsSqlServerNativeDatabaseMeta.java
+++
b/plugins/databases/mssqlnative/src/main/java/org/apache/hop/databases/mssqlnative/MsSqlServerNativeDatabaseMeta.java
@@ -180,11 +180,6 @@ public class MsSqlServerNativeDatabaseMeta extends
MsSqlServerDatabaseMeta
return null;
}
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
-
@Override
public boolean isMsSqlServerNativeVariant() {
return true;
diff --git
a/plugins/databases/postgresql/src/main/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMeta.java
b/plugins/databases/postgresql/src/main/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMeta.java
index c3304291aa..75089eaa72 100644
---
a/plugins/databases/postgresql/src/main/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMeta.java
+++
b/plugins/databases/postgresql/src/main/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMeta.java
@@ -1246,11 +1246,6 @@ public class PostgreSqlDatabaseMeta extends
BaseDatabaseMeta implements IDatabas
return true;
}
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
-
/**
* @return true if the database supports the use of safe-points and if it is
appropriate to ever
* use it (default to false)
diff --git
a/plugins/databases/postgresql/src/test/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMetaTest.java
b/plugins/databases/postgresql/src/test/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMetaTest.java
index 0532ac7464..54337c8b0f 100644
---
a/plugins/databases/postgresql/src/test/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMetaTest.java
+++
b/plugins/databases/postgresql/src/test/java/org/apache/hop/databases/postgresql/PostgreSqlDatabaseMetaTest.java
@@ -703,7 +703,6 @@ public class PostgreSqlDatabaseMetaTest {
nativeMeta.getExtraOptionsHelpText());
assertFalse(nativeMeta.IsSupportsErrorHandlingOnBatchUpdates());
assertTrue(nativeMeta.isRequiresCastToVariousForIsNull());
- assertFalse(nativeMeta.isSupportsGetBlob());
assertTrue(nativeMeta.isUseSafePoints());
assertTrue(nativeMeta.isSupportsBooleanDataType());
assertTrue(nativeMeta.isSupportsTimestampDataType());
diff --git
a/plugins/databases/vectorwise/src/main/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMeta.java
b/plugins/databases/vectorwise/src/main/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMeta.java
index 0a50f989a4..a36ed33836 100644
---
a/plugins/databases/vectorwise/src/main/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMeta.java
+++
b/plugins/databases/vectorwise/src/main/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMeta.java
@@ -191,9 +191,4 @@ public class VectorWiseDatabaseMeta extends
IngresDatabaseMeta implements IDatab
public String getTruncateTableStatement(String tableName) {
return "CALL VECTORWISE( COMBINE '" + tableName + " - " + tableName + "'
)";
}
-
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
}
diff --git
a/plugins/databases/vectorwise/src/test/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMetaTest.java
b/plugins/databases/vectorwise/src/test/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMetaTest.java
index 1412a57826..08e58324ec 100644
---
a/plugins/databases/vectorwise/src/test/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMetaTest.java
+++
b/plugins/databases/vectorwise/src/test/java/org/apache/hop/databases/vectorwise/VectorWiseDatabaseMetaTest.java
@@ -17,7 +17,6 @@
package org.apache.hop.databases.vectorwise;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
import org.apache.hop.core.database.DatabaseMeta;
import org.apache.hop.core.row.value.ValueMetaBigNumber;
@@ -65,8 +64,6 @@ class VectorWiseDatabaseMetaTest {
assertEquals(
"CALL VECTORWISE( COMBINE 'FOO - FOO' )",
nativeMeta.getTruncateTableStatement("FOO"));
-
- assertFalse(nativeMeta.isSupportsGetBlob());
}
@Test
diff --git
a/plugins/databases/vertica/src/main/java/org/apache/hop/databases/vertica/VerticaDatabaseMeta.java
b/plugins/databases/vertica/src/main/java/org/apache/hop/databases/vertica/VerticaDatabaseMeta.java
index d7d0fa4067..01ab94a849 100644
---
a/plugins/databases/vertica/src/main/java/org/apache/hop/databases/vertica/VerticaDatabaseMeta.java
+++
b/plugins/databases/vertica/src/main/java/org/apache/hop/databases/vertica/VerticaDatabaseMeta.java
@@ -663,14 +663,6 @@ public class VerticaDatabaseMeta extends BaseDatabaseMeta
implements IDatabase {
return false;
}
- /*
- * @return false as the database does not support BLOB data type
- */
- @Override
- public boolean isSupportsGetBlob() {
- return false;
- }
-
/**
* @return Handles the special case of Vertica where the display size
returned is twice the
* precision. In that case, the length is the precision.
diff --git
a/plugins/databases/vertica/src/test/java/org/apache/hop/databases/vertica/VerticaDatabaseMetaTest.java
b/plugins/databases/vertica/src/test/java/org/apache/hop/databases/vertica/VerticaDatabaseMetaTest.java
index 0702f6ba08..e69914ce91 100644
---
a/plugins/databases/vertica/src/test/java/org/apache/hop/databases/vertica/VerticaDatabaseMetaTest.java
+++
b/plugins/databases/vertica/src/test/java/org/apache/hop/databases/vertica/VerticaDatabaseMetaTest.java
@@ -482,7 +482,6 @@ class VerticaDatabaseMetaTest {
assertEquals("&", nativeMeta.getExtraOptionSeparator());
assertTrue(nativeMeta.isSupportsSequences());
assertFalse(nativeMeta.isSupportsTimeStampToDateConversion());
- assertFalse(nativeMeta.isSupportsGetBlob());
assertTrue(nativeMeta.isDisplaySizeTwiceThePrecision());
}
