Add JdbcSQLXML

h2/src/main/org/h2/jdbc/JdbcConnection.java

@@ -1653,11 +1653,20 @@ public class JdbcConnection extends TraceObject
     }
 
     /**
-     * [Not supported] Create a new empty SQLXML object.
+     * Create a new SQLXML object with no data.
+     *
+     * @return the object
      */
     @Override
     public SQLXML createSQLXML() throws SQLException {
-        throw unsupported("SQLXML");
+        try {
+            int id = getNextId(TraceObject.SQLXML);
+            debugCodeAssign("SQLXML", TraceObject.SQLXML, id, "createSQLXML()");
+            checkClosedForWrite();
+            return new JdbcSQLXML(this, ValueString.EMPTY, JdbcLob.State.NEW, id);
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
     }
 
     /**

h2/src/main/org/h2/jdbc/JdbcPreparedStatement.java

@@ -1777,11 +1777,29 @@ public class JdbcPreparedStatement extends JdbcStatement implements
     }
 
     /**
-     * [Not supported] Sets the value of a parameter as a SQLXML object.
+     * Sets the value of a parameter as a SQLXML.
+     *
+     * @param parameterIndex the parameter index (1, 2, ...)
+     * @param x the value
+     * @throws SQLException if this object is closed
      */
     @Override
     public void setSQLXML(int parameterIndex, SQLXML x) throws SQLException {
-        throw unsupported("SQLXML");
+        try {
+            if (isDebugEnabled()) {
+                debugCode("setSQLXML("+parameterIndex+", x);");
+            }
+            checkClosedForWrite();
+            Value v;
+            if (x == null) {
+                v = ValueNull.INSTANCE;
+            } else {
+                v = conn.createClob(x.getCharacterStream(), -1);
+            }
+            setParameter(parameterIndex, v);
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
     }
 
     /**

h2/src/main/org/h2/jdbc/JdbcResultSet.java

@@ -3519,39 +3519,91 @@ public class JdbcResultSet extends TraceObject implements ResultSet, JdbcResultS
     }
 
     /**
-     * [Not supported] Returns the value of the specified column as a SQLXML
-     * object.
+     * Returns the value of the specified column as a SQLXML.
+     *
+     * @param columnIndex (1,2,...)
+     * @return the value
+     * @throws SQLException if the column is not found or if the result set is
+     *             closed
      */
     @Override
     public SQLXML getSQLXML(int columnIndex) throws SQLException {
-        throw unsupported("SQLXML");
+        try {
+            int id = getNextId(TraceObject.SQLXML);
+            if (isDebugEnabled()) {
+                debugCodeAssign("SQLXML", TraceObject.SQLXML, id, "getSQLXML(" + columnIndex + ")");
+            }
+            Value v = get(columnIndex);
+            return v == ValueNull.INSTANCE ? null : new JdbcSQLXML(conn, v, JdbcLob.State.WITH_VALUE, id);
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
     }
 
     /**
-     * [Not supported] Returns the value of the specified column as a SQLXML
-     * object.
+     * Returns the value of the specified column as a SQLXML.
+     *
+     * @param columnLabel the column label
+     * @return the value
+     * @throws SQLException if the column is not found or if the result set is
+     *             closed
      */
     @Override
     public SQLXML getSQLXML(String columnLabel) throws SQLException {
-        throw unsupported("SQLXML");
+        try {
+            int id = getNextId(TraceObject.SQLXML);
+            if (isDebugEnabled()) {
+                debugCodeAssign("SQLXML", TraceObject.SQLXML, id, "getSQLXML(" + columnLabel + ")");
+            }
+            Value v = get(columnLabel);
+            return v == ValueNull.INSTANCE ? null : new JdbcSQLXML(conn, v, JdbcLob.State.WITH_VALUE, id);
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
     }
 
     /**
-     * [Not supported] Updates a column in the current or insert row.
+     * Updates a column in the current or insert row.
+     *
+     * @param columnIndex (1,2,...)
+     * @param x the value
+     * @throws SQLException if the result set is closed or not updatable
      */
     @Override
     public void updateSQLXML(int columnIndex, SQLXML xmlObject)
             throws SQLException {
-        throw unsupported("SQLXML");
+        try {
+            if (isDebugEnabled()) {
+                debugCode("updateSQLXML("+columnIndex+", x);");
+            }
+            checkClosed();
+            Value v = conn.createClob(xmlObject.getCharacterStream(), -1);
+            update(columnIndex, v);
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
     }
 
     /**
-     * [Not supported] Updates a column in the current or insert row.
+     * Updates a column in the current or insert row.
+     *
+     * @param columnLabel the column label
+     * @param x the value
+     * @throws SQLException if the result set is closed or not updatable
      */
     @Override
     public void updateSQLXML(String columnLabel, SQLXML xmlObject)
             throws SQLException {
-        throw unsupported("SQLXML");
+        try {
+            if (isDebugEnabled()) {
+                debugCode("updateSQLXML("+quote(columnLabel)+", x);");
+            }
+            checkClosed();
+            Value v = conn.createClob(xmlObject.getCharacterStream(), -1);
+            update(columnLabel, v);
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
     }
 
     /**

h2/src/main/org/h2/jdbc/JdbcSQLXML.java

+/*
+ * Copyright 2004-2018 H2 Group. Multiple-Licensed under the MPL 2.0,
+ * and the EPL 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.jdbc;
+
+import java.io.BufferedOutputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.sql.SQLException;
+import java.sql.SQLXML;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.sax.SAXResult;
+import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.sax.SAXTransformerFactory;
+import javax.xml.transform.sax.TransformerHandler;
+import javax.xml.transform.stax.StAXResult;
+import javax.xml.transform.stax.StAXSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import org.h2.message.DbException;
+import org.h2.message.TraceObject;
+import org.h2.value.Value;
+import org.w3c.dom.Node;
+import org.xml.sax.InputSource;
+
+/**
+ * Represents a SQLXML value.
+ */
+public class JdbcSQLXML extends JdbcLob implements SQLXML {
+
+    private DOMResult domResult;
+
+    /**
+     * Underlying stream for SAXResult, StAXResult, and StreamResult.
+     */
+    private Closeable closable;
+
+    /**
+     * INTERNAL
+     */
+    public JdbcSQLXML(JdbcConnection conn, Value value, State state, int id) {
+        super(conn, value, state, TraceObject.SQLXML, id);
+    }
+
+    @Override
+    void checkReadable() throws SQLException, IOException {
+        checkClosed();
+        if (state == State.SET_CALLED) {
+            if (domResult != null) {
+                Node node = domResult.getNode();
+                domResult = null;
+                TransformerFactory factory = TransformerFactory.newInstance();
+                try {
+                    Transformer transformer = factory.newTransformer();
+                    DOMSource domSource = new DOMSource(node);
+                    StringWriter stringWriter = new StringWriter();
+                    StreamResult streamResult = new StreamResult(stringWriter);
+                    transformer.transform(domSource, streamResult);
+                    completeWrite(conn.createClob(new StringReader(stringWriter.toString()), -1));
+                } catch (Exception e) {
+                    throw logAndConvert(e);
+                }
+                return;
+            } else if (closable != null) {
+                closable.close();
+                closable = null;
+                return;
+            }
+            throw DbException.getUnsupportedException("Stream setter is not yet closed.");
+        }
+    }
+
+    @Override
+    public InputStream getBinaryStream() throws SQLException {
+        return super.getBinaryStream();
+    }
+
+    @Override
+    public Reader getCharacterStream() throws SQLException {
+        return super.getCharacterStream();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends Source> T getSource(Class<T> sourceClass) throws SQLException {
+        try {
+            if (isDebugEnabled()) {
+                debugCodeCall(
+                        "getSource(" + (sourceClass != null ? sourceClass.getSimpleName() + ".class" : "null") + ')');
+            }
+            checkReadable();
+            if (sourceClass == null || sourceClass == DOMSource.class) {
+                DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+                return (T) new DOMSource(dbf.newDocumentBuilder().parse(new InputSource(value.getInputStream())));
+            } else if (sourceClass == SAXSource.class) {
+                return (T) new SAXSource(new InputSource(value.getInputStream()));
+            } else if (sourceClass == StAXSource.class) {
+                XMLInputFactory xif = XMLInputFactory.newInstance();
+                return (T) new StAXSource(xif.createXMLStreamReader(value.getInputStream()));
+            } else if (sourceClass == StreamSource.class) {
+                return (T) new StreamSource(value.getInputStream());
+            }
+            throw unsupported(sourceClass.getName());
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
+    }
+
+    @Override
+    public String getString() throws SQLException {
+        try {
+            debugCodeCall("getString");
+            checkReadable();
+            return value.getString();
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
+    }
+
+    @Override
+    public OutputStream setBinaryStream() throws SQLException {
+        try {
+            debugCodeCall("setBinaryStream");
+            checkEditable();
+            state = State.SET_CALLED;
+            return new BufferedOutputStream(setClobOutputStreamImpl());
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
+    }
+
+    @Override
+    public Writer setCharacterStream() throws SQLException {
+        try {
+            debugCodeCall("setCharacterStream");
+            checkEditable();
+            state = State.SET_CALLED;
+            return setCharacterStreamImpl();
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends Result> T setResult(Class<T> resultClass) throws SQLException {
+        try {
+            if (isDebugEnabled()) {
+                debugCodeCall(
+                        "getSource(" + (resultClass != null ? resultClass.getSimpleName() + ".class" : "null") + ')');
+            }
+            checkEditable();
+            if (resultClass == null || resultClass == DOMResult.class) {
+                domResult = new DOMResult();
+                state = State.SET_CALLED;
+                return (T) domResult;
+            } else if (resultClass == SAXResult.class) {
+                SAXTransformerFactory transformerFactory = (SAXTransformerFactory) TransformerFactory.newInstance();
+                TransformerHandler transformerHandler = transformerFactory.newTransformerHandler();
+                Writer writer = setCharacterStreamImpl();
+                transformerHandler.setResult(new StreamResult(writer));
+                SAXResult saxResult = new SAXResult(transformerHandler);
+                closable = writer;
+                state = State.SET_CALLED;
+                return (T) saxResult;
+            } else if (resultClass == StAXResult.class) {
+                XMLOutputFactory xof = XMLOutputFactory.newInstance();
+                Writer writer = setCharacterStreamImpl();
+                StAXResult staxResult = new StAXResult(xof.createXMLStreamWriter(writer));
+                closable = writer;
+                state = State.SET_CALLED;
+                return (T) staxResult;
+            } else if (StreamResult.class.equals(resultClass)) {
+                Writer writer = setCharacterStreamImpl();
+                StreamResult streamResult = new StreamResult(writer);
+                closable = writer;
+                state = State.SET_CALLED;
+                return (T) streamResult;
+            }
+            throw unsupported(resultClass.getName());
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
+    }
+
+    @Override
+    public void setString(String value) throws SQLException {
+        try {
+            if (isDebugEnabled()) {
+                debugCodeCall("getSource", value);
+            }
+            checkEditable();
+            completeWrite(conn.createClob(new StringReader(value), -1));
+        } catch (Exception e) {
+            throw logAndConvert(e);
+        }
+    }
+
+}

h2/src/main/org/h2/message/TraceObject.java

@@ -93,12 +93,17 @@ public class TraceObject {
      */
     protected static final int ARRAY = 16;
 
-    private static final int LAST = ARRAY + 1;
+    /**
+     * The trace type id  for SQLXML objects.
+     */
+    protected static final int SQLXML = 17;
+
+    private static final int LAST = SQLXML + 1;
     private static final AtomicIntegerArray ID = new AtomicIntegerArray(LAST);
 
     private static final String[] PREFIX = { "call", "conn", "dbMeta", "prep",
             "rs", "rsMeta", "sp", "ex", "stat", "blob", "clob", "pMeta", "ds",
-            "xads", "xares", "xid", "ar" };
+            "xads", "xares", "xid", "ar", "sqlxml" };
 
     /**
      * The trace module used by this object.

h2/src/test/org/h2/test/TestAll.java

@@ -102,6 +102,7 @@ import org.h2.test.jdbc.TestMetaData;
 import org.h2.test.jdbc.TestNativeSQL;
 import org.h2.test.jdbc.TestPreparedStatement;
 import org.h2.test.jdbc.TestResultSet;
+import org.h2.test.jdbc.TestSQLXML;
 import org.h2.test.jdbc.TestStatement;
 import org.h2.test.jdbc.TestTransactionIsolation;
 import org.h2.test.jdbc.TestUpdatableResultSet;
@@ -797,6 +798,7 @@ kill -9 `jps -l | grep "org.h2.test." | cut -d " " -f 1`
         addTest(new TestJavaObject());
         addTest(new TestLimitUpdates());
         addTest(new TestLobApi());
+        addTest(new TestSQLXML());
         addTest(new TestManyJdbcObjects());
         addTest(new TestMetaData());
         addTest(new TestNativeSQL());

h2/src/test/org/h2/test/jdbc/TestCallableStatement.java

@@ -111,8 +111,6 @@ public class TestCallableStatement extends TestDb {
                 setRef(1, (Ref) null);
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, call).
                 setRowId(1, (RowId) null);
-        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, call).
-                setSQLXML(1, (SQLXML) null);
 
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, call).
                 setURL("a", (URL) null);

h2/src/test/org/h2/test/jdbc/TestPreparedStatement.java

@@ -153,8 +153,6 @@ public class TestPreparedStatement extends TestDb {
 
         ParameterMetaData meta = prep.getParameterMetaData();
         assertTrue(meta.toString(), meta.toString().endsWith("parameterCount=1"));
-        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, conn).
-                createSQLXML();
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, conn).
                 createStruct("Integer", new Object[0]);
     }

h2/src/test/org/h2/test/jdbc/TestResultSet.java

@@ -26,7 +26,6 @@ import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.RowId;
 import java.sql.SQLException;
-import java.sql.SQLXML;
 import java.sql.Statement;
 import java.sql.Time;
 import java.sql.Timestamp;
@@ -161,10 +160,6 @@ public class TestResultSet extends TestDb {
                 getRowId(1);
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
                 getRowId("x");
-        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
-                getSQLXML(1);
-        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
-                getSQLXML("x");
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
                 updateRef(1, (Ref) null);
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
@@ -177,10 +172,6 @@ public class TestResultSet extends TestDb {
                 updateRowId(1, (RowId) null);
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
                 updateRowId("x", (RowId) null);
-        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
-                updateSQLXML(1, (SQLXML) null);
-        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
-                updateSQLXML("x", (SQLXML) null);
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).
                 getCursorName();
         assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, rs).

h2/src/test/org/h2/test/jdbc/TestSQLXML.java

+/*
+ * Copyright 2004-2018 H2 Group. Multiple-Licensed under the MPL 2.0,
+ * and the EPL 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.test.jdbc;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.StringReader;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.SQLXML;
+import java.sql.Statement;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.sax.SAXResult;
+import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.stax.StAXResult;
+import javax.xml.transform.stax.StAXSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import org.h2.api.ErrorCode;
+import org.h2.jdbc.JdbcConnection;
+import org.h2.test.TestBase;
+import org.h2.test.TestDb;
+import org.h2.util.IOUtils;
+import org.junit.Assert;
+import org.w3c.dom.Node;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ * Test the SQLXML implementation.
+ */
+public class TestSQLXML extends TestDb {
+    private static final String XML = "<xml a=\"v\">Text</xml>";
+
+    private JdbcConnection conn;
+    private Statement stat;
+
+    /**
+     * Run just this test.
+     *
+     * @param a
+     *            ignored
+     */
+    public static void main(String... a) throws Exception {
+        TestBase.createCaller().init().test();
+    }
+
+    @Override
+    public void test() throws Exception {
+        deleteDb(getTestName());
+        conn = (JdbcConnection) getConnection(getTestName());
+        stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, X CLOB)");
+        stat.execute("INSERT INTO TEST VALUES (1, NULL)");
+        testGetters();
+        testSetters();
+        conn.close();
+        deleteDb(getTestName());
+    }
+
+    private void testGetters() throws SQLException, IOException, XMLStreamException {
+        ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
+        assertTrue(rs.next());
+        assertNull(rs.getSQLXML(2));
+        assertNull(rs.getSQLXML("X"));
+        assertEquals(1, stat.executeUpdate("UPDATE TEST SET X = '" + XML + '\''));
+        rs = stat.executeQuery("SELECT * FROM TEST");
+        assertTrue(rs.next());
+        SQLXML sqlxml = rs.getSQLXML(2);
+        // getBinaryStream()
+        assertEquals(XML, IOUtils.readStringAndClose(IOUtils.getReader(sqlxml.getBinaryStream()), -1));
+        // getCharacterStream()
+        assertEquals(XML, IOUtils.readStringAndClose(sqlxml.getCharacterStream(), -1));
+        // getString()
+        assertEquals(XML, sqlxml.getString());
+        // DOMSource
+        DOMSource domSource = sqlxml.getSource(DOMSource.class);
+        Node n = domSource.getNode().getFirstChild();
+        assertEquals("xml", n.getNodeName());
+        assertEquals("v", n.getAttributes().getNamedItem("a").getNodeValue());
+        assertEquals("Text", n.getFirstChild().getNodeValue());
+        // SAXSource
+        SAXSource saxSource = sqlxml.getSource(SAXSource.class);
+        assertEquals(XML,
+                IOUtils.readStringAndClose(IOUtils.getReader(saxSource.getInputSource().getByteStream()), -1));
+        // StAXSource
+        StAXSource staxSource = sqlxml.getSource(StAXSource.class);
+        XMLStreamReader stxReader = staxSource.getXMLStreamReader();
+        assertEquals(XMLStreamReader.START_DOCUMENT, stxReader.getEventType());
+        assertEquals(XMLStreamReader.START_ELEMENT, stxReader.next());
+        assertEquals("xml", stxReader.getLocalName());
+        assertEquals("a", stxReader.getAttributeLocalName(0));
+        assertEquals("v", stxReader.getAttributeValue(0));
+        assertEquals(XMLStreamReader.CHARACTERS, stxReader.next());
+        assertEquals("Text", stxReader.getText());
+        assertEquals(XMLStreamReader.END_ELEMENT, stxReader.next());
+        assertEquals(XMLStreamReader.END_DOCUMENT, stxReader.next());
+        // StreamSource
+        StreamSource streamSource = sqlxml.getSource(StreamSource.class);
+        assertEquals(XML, IOUtils.readStringAndClose(IOUtils.getReader(streamSource.getInputStream()), -1));
+        // something illegal
+        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, sqlxml).getSource(Source.class);
+    }
+
+    private void testSetters() throws SQLException, IOException, SAXException, ParserConfigurationException,
+            TransformerConfigurationException, TransformerException {
+        // setBinaryStream()
+        SQLXML sqlxml = conn.createSQLXML();
+        try (OutputStream out = sqlxml.setBinaryStream()) {
+            out.write(XML.getBytes(StandardCharsets.UTF_8));
+        }
+        testSettersImpl(sqlxml);
+        // setCharacterStream()
+        sqlxml = conn.createSQLXML();
+        try (Writer out = sqlxml.setCharacterStream()) {
+            out.write(XML);
+        }
+        testSettersImpl(sqlxml);
+        // setString()
+        sqlxml = conn.createSQLXML();
+        sqlxml.setString(XML);
+        testSettersImpl(sqlxml);
+
+        TransformerFactory tf = TransformerFactory.newInstance();
+        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+        DOMSource domSource = new DOMSource(dbf.newDocumentBuilder().parse(new InputSource(new StringReader(XML))));
+        // DOMResult
+        sqlxml = conn.createSQLXML();
+        tf.newTransformer().transform(domSource, sqlxml.setResult(DOMResult.class));
+        testSettersImpl(sqlxml);
+        // SAXResult
+        sqlxml = conn.createSQLXML();
+        tf.newTransformer().transform(domSource, sqlxml.setResult(SAXResult.class));
+        testSettersImpl(sqlxml);
+        // StAXResult
+        sqlxml = conn.createSQLXML();
+        tf.newTransformer().transform(domSource, sqlxml.setResult(StAXResult.class));
+        testSettersImpl(sqlxml);
+        // StreamResult
+        sqlxml = conn.createSQLXML();
+        tf.newTransformer().transform(domSource, sqlxml.setResult(StreamResult.class));
+        testSettersImpl(sqlxml);
+        // something illegal
+        assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, sqlxml).setResult(Result.class);
+    }
+    
+    private static void assertXML(String actual) {
+        if (actual.startsWith("<?")) {
+            actual = actual.substring(actual.indexOf("?>") + 2);
+        }
+        Assert.assertEquals(XML, actual);
+    }
+
+    void testSettersImpl(SQLXML sqlxml) throws SQLException {
+        PreparedStatement prep = conn.prepareStatement("UPDATE TEST SET X = ?");
+        prep.setSQLXML(1, sqlxml);
+        assertEquals(1, prep.executeUpdate());
+        ResultSet rs = stat.executeQuery("SELECT X FROM TEST");
+        assertTrue(rs.next());
+        assertXML(rs.getSQLXML(1).getString());
+        Statement st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+        rs = st.executeQuery("SELECT * FROM TEST FOR UPDATE");
+        assertTrue(rs.next());
+        rs.updateSQLXML(2, sqlxml);
+        rs.updateRow();
+        rs = stat.executeQuery("SELECT X FROM TEST");
+        assertTrue(rs.next());
+        assertXML(rs.getSQLXML(1).getString());
+    }
+
+}