You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@calcite.apache.org by el...@apache.org on 2017/04/01 20:36:25 UTC
[36/37] calcite git commit: [CALCITE-1717] Remove avatica from the
tree
http://git-wip-us.apache.org/repos/asf/calcite/blob/5289d343/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaConnection.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaConnection.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaConnection.java
deleted file mode 100644
index 51649c1..0000000
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaConnection.java
+++ /dev/null
@@ -1,769 +0,0 @@
-/*
- * 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.calcite.avatica;
-
-import org.apache.calcite.avatica.Meta.ExecuteBatchResult;
-import org.apache.calcite.avatica.Meta.MetaResultSet;
-import org.apache.calcite.avatica.remote.KerberosConnection;
-import org.apache.calcite.avatica.remote.Service;
-import org.apache.calcite.avatica.remote.Service.ErrorResponse;
-import org.apache.calcite.avatica.remote.Service.OpenConnectionRequest;
-import org.apache.calcite.avatica.remote.TypedValue;
-
-import java.sql.Array;
-import java.sql.Blob;
-import java.sql.CallableStatement;
-import java.sql.Clob;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
-import java.sql.NClob;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLClientInfoException;
-import java.sql.SQLException;
-import java.sql.SQLWarning;
-import java.sql.SQLXML;
-import java.sql.Savepoint;
-import java.sql.Statement;
-import java.sql.Struct;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Properties;
-import java.util.TimeZone;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Executor;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * Implementation of JDBC connection
- * for the Avatica framework.
- *
- * <p>Abstract to allow newer versions of JDBC to add methods.
- */
-public abstract class AvaticaConnection implements Connection {
-
- /** The name of the sole column returned by DML statements, containing
- * the number of rows modified. */
- public static final String ROWCOUNT_COLUMN_NAME = "ROWCOUNT";
-
- public static final String NUM_EXECUTE_RETRIES_KEY = "avatica.statement.retries";
- public static final String NUM_EXECUTE_RETRIES_DEFAULT = "5";
-
- /** The name of the sole column returned by an EXPLAIN statement.
- *
- * <p>Actually Avatica does not care what this column is called, but here is
- * a useful place to define a suggested value. */
- public static final String PLAN_COLUMN_NAME = "PLAN";
-
- protected int statementCount;
- private boolean closed;
- private int holdability;
- private int networkTimeout;
- private KerberosConnection kerberosConnection;
- private Service service;
-
- public final String id;
- public final Meta.ConnectionHandle handle;
- protected final UnregisteredDriver driver;
- protected final AvaticaFactory factory;
- final String url;
- protected final Properties info;
- protected final Meta meta;
- protected final AvaticaSpecificDatabaseMetaData metaData;
- public final Helper helper = Helper.INSTANCE;
- public final Map<InternalProperty, Object> properties = new HashMap<>();
- public final Map<Integer, AvaticaStatement> statementMap =
- new ConcurrentHashMap<>();
- final Map<Integer, AtomicBoolean> flagMap = new ConcurrentHashMap<>();
- protected final long maxRetriesPerExecute;
-
- /**
- * Creates an AvaticaConnection.
- *
- * <p>Not public; method is called only from the driver or a derived
- * class.</p>
- *
- * @param driver Driver
- * @param factory Factory for JDBC objects
- * @param url Server URL
- * @param info Other connection properties
- */
- protected AvaticaConnection(UnregisteredDriver driver,
- AvaticaFactory factory,
- String url,
- Properties info) {
- this.id = UUID.randomUUID().toString();
- this.handle = new Meta.ConnectionHandle(this.id);
- this.driver = driver;
- this.factory = factory;
- this.url = url;
- this.info = info;
- this.meta = driver.createMeta(this);
- this.metaData = factory.newDatabaseMetaData(this);
- try {
- this.holdability = metaData.getResultSetHoldability();
- } catch (SQLException e) {
- // We know the impl doesn't throw this.
- throw new RuntimeException(e);
- }
- this.maxRetriesPerExecute = getNumStatementRetries(info);
- }
-
- /** Computes the number of retries
- * {@link AvaticaStatement#executeInternal(Meta.Signature, boolean)}
- * should retry before failing. */
- long getNumStatementRetries(Properties props) {
- return Long.valueOf(Objects.requireNonNull(props)
- .getProperty(NUM_EXECUTE_RETRIES_KEY, NUM_EXECUTE_RETRIES_DEFAULT));
- }
-
- /** Returns a view onto this connection's configuration properties. Code
- * in Avatica and derived projects should use this view rather than calling
- * {@link java.util.Properties#getProperty(String)}. Derived projects will
- * almost certainly subclass {@link ConnectionConfig} with their own
- * properties. */
- public ConnectionConfig config() {
- return new ConnectionConfigImpl(info);
- }
-
- /**
- * Opens the connection on the server.
- */
- public void openConnection() {
- // Open the connection on the server
- this.meta.openConnection(handle, OpenConnectionRequest.serializeProperties(info));
- }
-
- // Connection methods
-
- public AvaticaStatement createStatement() throws SQLException {
- //noinspection MagicConstant
- return createStatement(ResultSet.TYPE_FORWARD_ONLY,
- ResultSet.CONCUR_READ_ONLY,
- holdability);
- }
-
- public PreparedStatement prepareStatement(String sql) throws SQLException {
- //noinspection MagicConstant
- return prepareStatement(
- sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
- holdability);
- }
-
- public CallableStatement prepareCall(String sql) throws SQLException {
- throw helper.unsupported();
- }
-
- public String nativeSQL(String sql) throws SQLException {
- throw helper.unsupported();
- }
-
- public void setAutoCommit(boolean autoCommit) throws SQLException {
- meta.connectionSync(handle, new ConnectionPropertiesImpl().setAutoCommit(autoCommit));
- }
-
- public boolean getAutoCommit() throws SQLException {
- return unbox(sync().isAutoCommit(), true);
- }
-
- public void commit() throws SQLException {
- meta.commit(handle);
- }
-
- public void rollback() throws SQLException {
- meta.rollback(handle);
- }
-
- public void close() throws SQLException {
- if (!closed) {
- closed = true;
-
- // Per specification, if onConnectionClose throws, this method will throw
- // a SQLException, but statement will still be closed.
- try {
- meta.closeConnection(handle);
- driver.handler.onConnectionClose(this);
- if (null != kerberosConnection) {
- kerberosConnection.stopRenewalThread();
- }
- } catch (RuntimeException e) {
- throw helper.createException("While closing connection", e);
- }
- }
- }
-
- public boolean isClosed() throws SQLException {
- return closed;
- }
-
- public DatabaseMetaData getMetaData() throws SQLException {
- return metaData;
- }
-
- public void setReadOnly(boolean readOnly) throws SQLException {
- meta.connectionSync(handle, new ConnectionPropertiesImpl().setReadOnly(readOnly));
- }
-
- public boolean isReadOnly() throws SQLException {
- return unbox(sync().isReadOnly(), true);
- }
-
- public void setCatalog(String catalog) throws SQLException {
- meta.connectionSync(handle, new ConnectionPropertiesImpl().setCatalog(catalog));
- }
-
- public String getCatalog() {
- return sync().getCatalog();
- }
-
- public void setTransactionIsolation(int level) throws SQLException {
- meta.connectionSync(handle, new ConnectionPropertiesImpl().setTransactionIsolation(level));
- }
-
- public int getTransactionIsolation() throws SQLException {
- //noinspection MagicConstant
- return unbox(sync().getTransactionIsolation(), TRANSACTION_NONE);
- }
-
- public SQLWarning getWarnings() throws SQLException {
- return null;
- }
-
- public void clearWarnings() throws SQLException {
- // no-op since connection pooling often calls this.
- }
-
- public Statement createStatement(
- int resultSetType, int resultSetConcurrency) throws SQLException {
- //noinspection MagicConstant
- return createStatement(resultSetType, resultSetConcurrency, holdability);
- }
-
- public PreparedStatement prepareStatement(
- String sql,
- int resultSetType,
- int resultSetConcurrency) throws SQLException {
- //noinspection MagicConstant
- return prepareStatement(
- sql, resultSetType, resultSetConcurrency, holdability);
- }
-
- public CallableStatement prepareCall(
- String sql,
- int resultSetType,
- int resultSetConcurrency) throws SQLException {
- throw helper.unsupported();
- }
-
- public Map<String, Class<?>> getTypeMap() throws SQLException {
- throw helper.unsupported();
- }
-
- public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
- throw helper.unsupported();
- }
-
- public void setHoldability(int holdability) throws SQLException {
- if (!(holdability == ResultSet.CLOSE_CURSORS_AT_COMMIT
- || holdability == ResultSet.HOLD_CURSORS_OVER_COMMIT)) {
- throw new SQLException("invalid value");
- }
- this.holdability = holdability;
- }
-
- public int getHoldability() throws SQLException {
- return holdability;
- }
-
- public Savepoint setSavepoint() throws SQLException {
- throw helper.unsupported();
- }
-
- public Savepoint setSavepoint(String name) throws SQLException {
- throw helper.unsupported();
- }
-
- public void rollback(Savepoint savepoint) throws SQLException {
- throw helper.unsupported();
- }
-
- public void releaseSavepoint(Savepoint savepoint) throws SQLException {
- throw helper.unsupported();
- }
-
- public AvaticaStatement createStatement(
- int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
- return factory.newStatement(this, null, resultSetType, resultSetConcurrency,
- resultSetHoldability);
- }
-
- public PreparedStatement prepareStatement(
- String sql,
- int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
- try {
- final Meta.StatementHandle h = meta.prepare(handle, sql, -1);
- return factory.newPreparedStatement(this, h, h.signature, resultSetType,
- resultSetConcurrency, resultSetHoldability);
- } catch (RuntimeException e) {
- throw helper.createException("while preparing SQL: " + sql, e);
- }
- }
-
- public CallableStatement prepareCall(
- String sql,
- int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
- throw helper.unsupported();
- }
-
- public PreparedStatement prepareStatement(
- String sql, int autoGeneratedKeys) throws SQLException {
- throw helper.unsupported();
- }
-
- public PreparedStatement prepareStatement(
- String sql, int[] columnIndexes) throws SQLException {
- throw helper.unsupported();
- }
-
- public PreparedStatement prepareStatement(
- String sql, String[] columnNames) throws SQLException {
- throw helper.unsupported();
- }
-
- public Clob createClob() throws SQLException {
- throw helper.unsupported();
- }
-
- public Blob createBlob() throws SQLException {
- throw helper.unsupported();
- }
-
- public NClob createNClob() throws SQLException {
- throw helper.unsupported();
- }
-
- public SQLXML createSQLXML() throws SQLException {
- throw helper.unsupported();
- }
-
- public boolean isValid(int timeout) throws SQLException {
- throw helper.unsupported();
- }
-
- public void setClientInfo(String name, String value)
- throws SQLClientInfoException {
- throw helper.clientInfo();
- }
-
- public void setClientInfo(Properties properties)
- throws SQLClientInfoException {
- throw helper.clientInfo();
- }
-
- public String getClientInfo(String name) throws SQLException {
- throw helper.unsupported();
- }
-
- public Properties getClientInfo() throws SQLException {
- throw helper.unsupported();
- }
-
- public Array createArrayOf(String typeName, Object[] elements)
- throws SQLException {
- throw helper.unsupported();
- }
-
- public Struct createStruct(String typeName, Object[] attributes)
- throws SQLException {
- throw helper.unsupported();
- }
-
- public void setSchema(String schema) throws SQLException {
- meta.connectionSync(handle, new ConnectionPropertiesImpl().setSchema(schema));
- }
-
- public String getSchema() {
- return sync().getSchema();
- }
-
- public void abort(Executor executor) throws SQLException {
- throw helper.unsupported();
- }
-
- public void setNetworkTimeout(
- Executor executor, int milliseconds) throws SQLException {
- this.networkTimeout = milliseconds;
- }
-
- public int getNetworkTimeout() throws SQLException {
- return networkTimeout;
- }
-
- public <T> T unwrap(Class<T> iface) throws SQLException {
- if (iface.isInstance(this)) {
- return iface.cast(this);
- }
- throw helper.createException(
- "does not implement '" + iface + "'");
- }
-
- public boolean isWrapperFor(Class<?> iface) throws SQLException {
- return iface.isInstance(this);
- }
-
- /** Returns the time zone of this connection. Determines the offset applied
- * when converting datetime values from the database into
- * {@link java.sql.Timestamp} values. */
- public TimeZone getTimeZone() {
- final String timeZoneName = config().timeZone();
- return timeZoneName == null
- ? TimeZone.getDefault()
- : TimeZone.getTimeZone(timeZoneName);
- }
-
- /**
- * Executes a prepared query, closing any previously open result set.
- *
- * @param statement Statement
- * @param signature Prepared query
- * @param firstFrame First frame of rows, or null if we need to execute
- * @param state The state used to create the given result
- * @param isUpdate Was the caller context via {@link PreparedStatement#executeUpdate()}.
- * @return Result set
- * @throws java.sql.SQLException if a database error occurs
- */
- protected ResultSet executeQueryInternal(AvaticaStatement statement,
- Meta.Signature signature, Meta.Frame firstFrame, QueryState state, boolean isUpdate)
- throws SQLException {
- // Close the previous open result set, if there is one.
- Meta.Frame frame = firstFrame;
- Meta.Signature signature2 = signature;
-
- synchronized (statement) {
- if (statement.openResultSet != null) {
- final AvaticaResultSet rs = statement.openResultSet;
- statement.openResultSet = null;
- try {
- rs.close();
- } catch (Exception e) {
- throw helper.createException(
- "Error while closing previous result set", e);
- }
- }
-
- try {
- if (statement.isWrapperFor(AvaticaPreparedStatement.class)) {
- final AvaticaPreparedStatement pstmt = (AvaticaPreparedStatement) statement;
- Meta.StatementHandle handle = pstmt.handle;
- if (isUpdate) {
- // Make a copy of the StatementHandle, nulling out the Signature.
- // CALCITE-1086 we don't need to send the Signature to the server
- // when we're only performing an update. Saves on serialization.
- handle = new Meta.StatementHandle(handle.connectionId, handle.id, null);
- }
- final Meta.ExecuteResult executeResult =
- meta.execute(handle, pstmt.getParameterValues(),
- statement.getFetchSize());
- final MetaResultSet metaResultSet = executeResult.resultSets.get(0);
- frame = metaResultSet.firstFrame;
- statement.updateCount = metaResultSet.updateCount;
- signature2 = executeResult.resultSets.get(0).signature;
- }
- } catch (Exception e) {
- e.printStackTrace();
- throw helper.createException(e.getMessage(), e);
- }
-
- final TimeZone timeZone = getTimeZone();
- if (frame == null && signature2 == null && statement.updateCount != -1) {
- statement.openResultSet = null;
- } else {
- // Duplicative SQL, for support non-prepared statements
- statement.openResultSet =
- factory.newResultSet(statement, state, signature2, timeZone, frame);
- }
- }
- // Release the monitor before executing, to give another thread the
- // opportunity to call cancel.
- try {
- if (statement.openResultSet != null) {
- statement.openResultSet.execute();
- isUpdateCapable(statement);
- }
- } catch (Exception e) {
- throw helper.createException(
- "exception while executing query: " + e.getMessage(), e);
- }
- return statement.openResultSet;
- }
-
- /** Executes a batch update using an {@link AvaticaPreparedStatement}.
- *
- * @param pstmt The prepared statement.
- * @return An array of update counts containing one element for each command in the batch.
- */
- protected long[] executeBatchUpdateInternal(AvaticaPreparedStatement pstmt) throws SQLException {
- try {
- // Get the handle from the statement
- Meta.StatementHandle handle = pstmt.handle;
- // Execute it against meta
- return meta.executeBatch(handle, pstmt.getParameterValueBatch()).updateCounts;
- } catch (Exception e) {
- throw helper.createException(e.getMessage(), e);
- }
- }
-
- /** Returns whether a a statement is capable of updates and if so,
- * and the statement's {@code updateCount} is still -1, proceeds to
- * get updateCount value from statement's resultSet.
- *
- * <p>Handles "ROWCOUNT" object as Number or List
- *
- * @param statement Statement
- * @throws SQLException on error
- */
- private void isUpdateCapable(final AvaticaStatement statement)
- throws SQLException {
- Meta.Signature signature = statement.getSignature();
- if (signature == null || signature.statementType == null) {
- return;
- }
- if (signature.statementType.canUpdate() && statement.updateCount == -1) {
- statement.openResultSet.next();
- Object obj = statement.openResultSet.getObject(ROWCOUNT_COLUMN_NAME);
- if (obj instanceof Number) {
- statement.updateCount = ((Number) obj).intValue();
- } else if (obj instanceof List) {
- @SuppressWarnings("unchecked")
- final List<Number> numbers = (List<Number>) obj;
- statement.updateCount = numbers.get(0).intValue();
- } else {
- throw helper.createException("Not a valid return result.");
- }
- statement.openResultSet = null;
- }
- }
-
- protected Meta.ExecuteResult prepareAndExecuteInternal(
- final AvaticaStatement statement, final String sql, long maxRowCount)
- throws SQLException, NoSuchStatementException {
- final Meta.PrepareCallback callback =
- new Meta.PrepareCallback() {
- public Object getMonitor() {
- return statement;
- }
-
- public void clear() throws SQLException {
- if (statement.openResultSet != null) {
- final AvaticaResultSet rs = statement.openResultSet;
- statement.openResultSet = null;
- try {
- rs.close();
- } catch (Exception e) {
- throw helper.createException(
- "Error while closing previous result set", e);
- }
- }
- }
-
- public void assign(Meta.Signature signature, Meta.Frame firstFrame,
- long updateCount) throws SQLException {
- statement.setSignature(signature);
-
- if (updateCount != -1) {
- statement.updateCount = updateCount;
- } else {
- final TimeZone timeZone = getTimeZone();
- statement.openResultSet = factory.newResultSet(statement, new QueryState(sql),
- signature, timeZone, firstFrame);
- }
- }
-
- public void execute() throws SQLException {
- if (statement.openResultSet != null) {
- statement.openResultSet.execute();
- isUpdateCapable(statement);
- }
- }
- };
- // The old semantics were that maxRowCount was also treated as the maximum number of
- // elements in the first Frame of results. A value of -1 would also preserve this, but an
- // explicit (positive) number is easier to follow, IMO.
- return meta.prepareAndExecute(statement.handle, sql, maxRowCount,
- AvaticaUtils.toSaturatedInt(maxRowCount), callback);
- }
-
- protected ExecuteBatchResult prepareAndUpdateBatch(final AvaticaStatement statement,
- final List<String> queries) throws NoSuchStatementException, SQLException {
- return meta.prepareAndExecuteBatch(statement.handle, queries);
- }
-
- protected ResultSet createResultSet(Meta.MetaResultSet metaResultSet, QueryState state)
- throws SQLException {
- final Meta.StatementHandle h = new Meta.StatementHandle(
- metaResultSet.connectionId, metaResultSet.statementId, null);
- final AvaticaStatement statement = lookupStatement(h);
- // These are all the metadata operations, no updates
- ResultSet resultSet = executeQueryInternal(statement, metaResultSet.signature.sanitize(),
- metaResultSet.firstFrame, state, false);
- if (metaResultSet.ownStatement) {
- resultSet.getStatement().closeOnCompletion();
- }
- return resultSet;
- }
-
- /** Creates a statement wrapper around an existing handle. */
- protected AvaticaStatement lookupStatement(Meta.StatementHandle h)
- throws SQLException {
- final AvaticaStatement statement = statementMap.get(h.id);
- if (statement != null) {
- return statement;
- }
- //noinspection MagicConstant
- return factory.newStatement(this, Objects.requireNonNull(h),
- ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, holdability);
- }
-
- // do not make public
- protected static Trojan createTrojan() {
- return new Trojan();
- }
-
- /** Converts a {@link Boolean} to a {@code boolean}, with a default value. */
- private boolean unbox(Boolean b, boolean defaultValue) {
- return b == null ? defaultValue : b;
- }
-
- /** Converts an {@link Integer} to an {@code int}, with a default value. */
- private int unbox(Integer i, int defaultValue) {
- return i == null ? defaultValue : i;
- }
-
- private Meta.ConnectionProperties sync() {
- return meta.connectionSync(handle, new ConnectionPropertiesImpl());
- }
-
- /** Returns or creates a slot whose state can be changed to cancel a
- * statement. Statements will receive the same slot if and only if their id
- * is the same. */
- public AtomicBoolean getCancelFlag(Meta.StatementHandle h)
- throws NoSuchStatementException {
- AvaticaUtils.upgrade("after dropping JDK 1.7, use Map.computeIfAbsent");
- synchronized (flagMap) {
- AtomicBoolean b = flagMap.get(h.id);
- if (b == null) {
- b = new AtomicBoolean();
- flagMap.put(h.id, b);
- }
- return b;
- }
- }
-
- /** A way to call package-protected methods. But only a sub-class of
- * connection can create one. */
- public static class Trojan {
- // must be private
- private Trojan() {
- }
-
- /** A means for anyone who has a trojan to call the protected method
- * {@link org.apache.calcite.avatica.AvaticaResultSet#execute()}.
- * @throws SQLException if execute fails for some reason. */
- public ResultSet execute(AvaticaResultSet resultSet) throws SQLException {
- return resultSet.execute();
- }
-
- /** A means for anyone who has a trojan to call the protected method
- * {@link org.apache.calcite.avatica.AvaticaStatement#getParameterValues()}.
- */
- public List<TypedValue> getParameterValues(AvaticaStatement statement) {
- return statement.getParameterValues();
- }
-
- /** A means for anyone who has a trojan to get the protected field
- * {@link org.apache.calcite.avatica.AvaticaConnection#meta}. */
- public Meta getMeta(AvaticaConnection connection) {
- return connection.meta;
- }
- }
-
- /**
- * A Callable-like interface but without a "throws Exception".
- *
- * @param <T> The return type from {@code call}.
- */
- public interface CallableWithoutException<T> {
- T call();
- }
-
- /**
- * Invokes the given "callable", retrying the call when the server responds with an error
- * denoting that the connection is missing on the server.
- *
- * @param callable The function to invoke.
- * @return The value from the result of the callable.
- */
- public <T> T invokeWithRetries(CallableWithoutException<T> callable) {
- RuntimeException lastException = null;
- for (int i = 0; i < maxRetriesPerExecute; i++) {
- try {
- return callable.call();
- } catch (AvaticaClientRuntimeException e) {
- lastException = e;
- if (ErrorResponse.MISSING_CONNECTION_ERROR_CODE == e.getErrorCode()) {
- this.openConnection();
- continue;
- }
- throw e;
- }
- }
- if (null != lastException) {
- throw lastException;
- } else {
- // Shouldn't ever happen.
- throw new IllegalStateException();
- }
- }
-
- public void setKerberosConnection(KerberosConnection kerberosConnection) {
- this.kerberosConnection = Objects.requireNonNull(kerberosConnection);
- }
-
- public KerberosConnection getKerberosConnection() {
- return this.kerberosConnection;
- }
-
- public Service getService() {
- assert null != service;
- return service;
- }
-
- public void setService(Service service) {
- this.service = Objects.requireNonNull(service);
- }
-}
-
-// End AvaticaConnection.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/5289d343/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaDatabaseMetaData.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaDatabaseMetaData.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaDatabaseMetaData.java
deleted file mode 100644
index 7182968..0000000
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaDatabaseMetaData.java
+++ /dev/null
@@ -1,1460 +0,0 @@
-/*
- * 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.calcite.avatica;
-
-import org.apache.calcite.avatica.AvaticaConnection.CallableWithoutException;
-import org.apache.calcite.avatica.Meta.DatabaseProperty;
-import org.apache.calcite.avatica.remote.MetaDataOperation;
-import org.apache.calcite.avatica.util.Casing;
-import org.apache.calcite.avatica.util.Quoting;
-
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.RowIdLifetime;
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Properties;
-
-import static org.apache.calcite.avatica.InternalProperty.CASE_SENSITIVE;
-import static org.apache.calcite.avatica.InternalProperty.NULL_SORTING;
-import static org.apache.calcite.avatica.InternalProperty.NullSorting;
-import static org.apache.calcite.avatica.InternalProperty.QUOTED_CASING;
-import static org.apache.calcite.avatica.InternalProperty.QUOTING;
-import static org.apache.calcite.avatica.InternalProperty.UNQUOTED_CASING;
-
-/**
- * Implementation of {@link java.sql.DatabaseMetaData}
- * for the Avatica engine.
- *
- * <p>This class has sub-classes which implement JDBC 3.0 and JDBC 4.0 APIs;
- * it is instantiated using {@link AvaticaFactory#newDatabaseMetaData}.</p>
- */
-public class AvaticaDatabaseMetaData implements AvaticaSpecificDatabaseMetaData {
- private final AvaticaConnection connection;
-
- protected AvaticaDatabaseMetaData(AvaticaConnection connection) {
- this.connection = connection;
- }
-
- // Helper methods
-
- private NullSorting nullSorting() {
- return NULL_SORTING.getEnum(getProperties(), NullSorting.class);
- }
-
- private Quoting quoting() {
- return QUOTING.getEnum(getProperties(), Quoting.class);
- }
-
- private Casing unquotedCasing() {
- return UNQUOTED_CASING.getEnum(getProperties(), Casing.class);
- }
-
- private Casing quotedCasing() {
- return QUOTED_CASING.getEnum(getProperties(), Casing.class);
- }
-
- private boolean caseSensitive() {
- return CASE_SENSITIVE.getBoolean(getProperties());
- }
-
- // JDBC methods
-
- public boolean allProceduresAreCallable() throws SQLException {
- return true;
- }
-
- public boolean allTablesAreSelectable() throws SQLException {
- return true;
- }
-
- public String getURL() throws SQLException {
- return connection.url;
- }
-
- public String getUserName() throws SQLException {
- return connection.info.getProperty("user");
- }
-
- public boolean isReadOnly() throws SQLException {
- return true;
- }
-
- public boolean nullsAreSortedHigh() throws SQLException {
- return nullSorting() == NullSorting.HIGH;
- }
-
- public boolean nullsAreSortedLow() throws SQLException {
- return nullSorting() == NullSorting.LOW;
- }
-
- public boolean nullsAreSortedAtStart() throws SQLException {
- return nullSorting() == NullSorting.START;
- }
-
- public boolean nullsAreSortedAtEnd() throws SQLException {
- return nullSorting() == NullSorting.END;
- }
-
- public String getDatabaseProductName() throws SQLException {
- return connection.driver.version.productName;
- }
-
- public String getDatabaseProductVersion() throws SQLException {
- return connection.driver.version.productVersion;
- }
-
- public String getDriverName() throws SQLException {
- return connection.driver.version.name;
- }
-
- public String getDriverVersion() throws SQLException {
- return connection.driver.version.versionString;
- }
-
- public int getDriverMajorVersion() {
- return connection.driver.getMajorVersion();
- }
-
- public int getDriverMinorVersion() {
- return connection.driver.getMinorVersion();
- }
-
- public boolean usesLocalFiles() throws SQLException {
- return false;
- }
-
- public boolean usesLocalFilePerTable() throws SQLException {
- return false;
- }
-
- public boolean storesMixedCaseIdentifiers() throws SQLException {
- return !caseSensitive() && unquotedCasing() == Casing.UNCHANGED;
- }
-
- public boolean supportsMixedCaseIdentifiers() throws SQLException {
- return caseSensitive() && unquotedCasing() == Casing.UNCHANGED;
- }
-
- public boolean storesUpperCaseIdentifiers() throws SQLException {
- return unquotedCasing() == Casing.TO_UPPER;
- }
-
- public boolean storesLowerCaseIdentifiers() throws SQLException {
- return unquotedCasing() == Casing.TO_LOWER;
- }
-
- public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
- return !caseSensitive() && quotedCasing() == Casing.UNCHANGED;
- }
-
- public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
- return caseSensitive() && quotedCasing() == Casing.UNCHANGED;
- }
-
- public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
- return quotedCasing() == Casing.TO_UPPER;
- }
-
- public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
- return quotedCasing() == Casing.TO_LOWER;
- }
-
- public String getIdentifierQuoteString() throws SQLException {
- return quoting().string;
- }
-
- private Map<InternalProperty, Object> getProperties() {
- return connection.properties;
- }
-
- public String getSQLKeywords() throws SQLException {
- return connection.invokeWithRetries(
- new CallableWithoutException<String>() {
- public String call() {
- return Meta.DatabaseProperty.GET_S_Q_L_KEYWORDS
- .getProp(connection.meta, connection.handle, String.class);
- }
- });
- }
-
- public String getNumericFunctions() throws SQLException {
- return connection.invokeWithRetries(
- new CallableWithoutException<String>() {
- public String call() {
- return Meta.DatabaseProperty.GET_NUMERIC_FUNCTIONS
- .getProp(connection.meta, connection.handle, String.class);
- }
- });
- }
-
- public String getStringFunctions() throws SQLException {
- return connection.invokeWithRetries(
- new CallableWithoutException<String>() {
- public String call() {
- return Meta.DatabaseProperty.GET_STRING_FUNCTIONS
- .getProp(connection.meta, connection.handle, String.class);
- }
- });
- }
-
- public String getSystemFunctions() throws SQLException {
- return connection.invokeWithRetries(
- new CallableWithoutException<String>() {
- public String call() {
- return Meta.DatabaseProperty.GET_SYSTEM_FUNCTIONS
- .getProp(connection.meta, connection.handle, String.class);
- }
- });
- }
-
- public String getTimeDateFunctions() throws SQLException {
- return connection.invokeWithRetries(
- new CallableWithoutException<String>() {
- public String call() {
- return Meta.DatabaseProperty.GET_TIME_DATE_FUNCTIONS
- .getProp(connection.meta, connection.handle, String.class);
- }
- });
- }
-
- public String getSearchStringEscape() throws SQLException {
- return "\\";
- }
-
- public String getExtraNameCharacters() throws SQLException {
- return "";
- }
-
- public boolean supportsAlterTableWithAddColumn() throws SQLException {
- return false;
- }
-
- public boolean supportsAlterTableWithDropColumn() throws SQLException {
- return false;
- }
-
- public boolean supportsColumnAliasing() throws SQLException {
- return true;
- }
-
- public boolean nullPlusNonNullIsNull() throws SQLException {
- return true;
- }
-
- public boolean supportsConvert() throws SQLException {
- return true;
- }
-
- public boolean supportsConvert(int fromType, int toType) throws SQLException {
- return false; // TODO: more detail
- }
-
- public boolean supportsTableCorrelationNames() throws SQLException {
- return true;
- }
-
- public boolean supportsDifferentTableCorrelationNames() throws SQLException {
- return true;
- }
-
- public boolean supportsExpressionsInOrderBy() throws SQLException {
- return true;
- }
-
- public boolean supportsOrderByUnrelated() throws SQLException {
- return true;
- }
-
- public boolean supportsGroupBy() throws SQLException {
- return true;
- }
-
- public boolean supportsGroupByUnrelated() throws SQLException {
- return true;
- }
-
- public boolean supportsGroupByBeyondSelect() throws SQLException {
- return true;
- }
-
- public boolean supportsLikeEscapeClause() throws SQLException {
- return true;
- }
-
- public boolean supportsMultipleResultSets() throws SQLException {
- return false;
- }
-
- public boolean supportsMultipleTransactions() throws SQLException {
- return false;
- }
-
- public boolean supportsNonNullableColumns() throws SQLException {
- return true;
- }
-
- public boolean supportsMinimumSQLGrammar() throws SQLException {
- return true;
- }
-
- public boolean supportsCoreSQLGrammar() throws SQLException {
- return true;
- }
-
- public boolean supportsExtendedSQLGrammar() throws SQLException {
- return true;
- }
-
- public boolean supportsANSI92EntryLevelSQL() throws SQLException {
- return true;
- }
-
- public boolean supportsANSI92IntermediateSQL() throws SQLException {
- return true;
- }
-
- public boolean supportsANSI92FullSQL() throws SQLException {
- return true;
- }
-
- public boolean supportsIntegrityEnhancementFacility() throws SQLException {
- return false;
- }
-
- public boolean supportsOuterJoins() throws SQLException {
- return true;
- }
-
- public boolean supportsFullOuterJoins() throws SQLException {
- return true;
- }
-
- public boolean supportsLimitedOuterJoins() throws SQLException {
- return true;
- }
-
- public String getSchemaTerm() throws SQLException {
- return "schema";
- }
-
- public String getProcedureTerm() throws SQLException {
- return "procedure";
- }
-
- public String getCatalogTerm() throws SQLException {
- return "catalog";
- }
-
- public boolean isCatalogAtStart() throws SQLException {
- return true;
- }
-
- public String getCatalogSeparator() throws SQLException {
- return ".";
- }
-
- public boolean supportsSchemasInDataManipulation() throws SQLException {
- return true;
- }
-
- public boolean supportsSchemasInProcedureCalls() throws SQLException {
- return true;
- }
-
- public boolean supportsSchemasInTableDefinitions() throws SQLException {
- return true;
- }
-
- public boolean supportsSchemasInIndexDefinitions() throws SQLException {
- return true; // except that we don't support index definitions
- }
-
- public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
- return true; // except that we don't support privilege definitions
- }
-
- public boolean supportsCatalogsInDataManipulation() throws SQLException {
- return true;
- }
-
- public boolean supportsCatalogsInProcedureCalls() throws SQLException {
- return true;
- }
-
- public boolean supportsCatalogsInTableDefinitions() throws SQLException {
- return true;
- }
-
- public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
- return true; // except that we don't support index definitions
- }
-
- public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
- return true; // except that we don't support privilege definitions
- }
-
- public boolean supportsPositionedDelete() throws SQLException {
- return false;
- }
-
- public boolean supportsPositionedUpdate() throws SQLException {
- return false;
- }
-
- public boolean supportsSelectForUpdate() throws SQLException {
- return false;
- }
-
- public boolean supportsStoredProcedures() throws SQLException {
- return false;
- }
-
- public boolean supportsSubqueriesInComparisons() throws SQLException {
- return true;
- }
-
- public boolean supportsSubqueriesInExists() throws SQLException {
- return true;
- }
-
- public boolean supportsSubqueriesInIns() throws SQLException {
- return true;
- }
-
- public boolean supportsSubqueriesInQuantifieds() throws SQLException {
- return false;
- }
-
- public boolean supportsCorrelatedSubqueries() throws SQLException {
- return true;
- }
-
- public boolean supportsUnion() throws SQLException {
- return true;
- }
-
- public boolean supportsUnionAll() throws SQLException {
- return true;
- }
-
- public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
- return false;
- }
-
- public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
- return false;
- }
-
- public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
- return false;
- }
-
- public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
- return false;
- }
-
- public int getMaxBinaryLiteralLength() throws SQLException {
- return 0;
- }
-
- public int getMaxCharLiteralLength() throws SQLException {
- return 0;
- }
-
- public int getMaxColumnNameLength() throws SQLException {
- return 0;
- }
-
- public int getMaxColumnsInGroupBy() throws SQLException {
- return 0;
- }
-
- public int getMaxColumnsInIndex() throws SQLException {
- return 0;
- }
-
- public int getMaxColumnsInOrderBy() throws SQLException {
- return 0;
- }
-
- public int getMaxColumnsInSelect() throws SQLException {
- return 0;
- }
-
- public int getMaxColumnsInTable() throws SQLException {
- return 0;
- }
-
- public int getMaxConnections() throws SQLException {
- return 0;
- }
-
- public int getMaxCursorNameLength() throws SQLException {
- return 0;
- }
-
- public int getMaxIndexLength() throws SQLException {
- return 0;
- }
-
- public int getMaxSchemaNameLength() throws SQLException {
- return 0;
- }
-
- public int getMaxProcedureNameLength() throws SQLException {
- return 0;
- }
-
- public int getMaxCatalogNameLength() throws SQLException {
- return 0;
- }
-
- public int getMaxRowSize() throws SQLException {
- return 0;
- }
-
- public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
- return false;
- }
-
- public int getMaxStatementLength() throws SQLException {
- return 0;
- }
-
- public int getMaxStatements() throws SQLException {
- return 0;
- }
-
- public int getMaxTableNameLength() throws SQLException {
- return 0;
- }
-
- public int getMaxTablesInSelect() throws SQLException {
- return 0;
- }
-
- public int getMaxUserNameLength() throws SQLException {
- return 0;
- }
-
- public int getDefaultTransactionIsolation() throws SQLException {
- return connection.invokeWithRetries(
- new CallableWithoutException<Integer>() {
- public Integer call() {
- return Meta.DatabaseProperty.GET_DEFAULT_TRANSACTION_ISOLATION
- .getProp(connection.meta, connection.handle, Integer.class);
- }
- });
- }
-
- public boolean supportsTransactions() throws SQLException {
- return false;
- }
-
- public boolean supportsTransactionIsolationLevel(int level)
- throws SQLException {
- return level == Connection.TRANSACTION_NONE;
- }
-
- public boolean supportsDataDefinitionAndDataManipulationTransactions()
- throws SQLException {
- return false;
- }
-
- public boolean supportsDataManipulationTransactionsOnly()
- throws SQLException {
- return true;
- }
-
- public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
- return true;
- }
-
- public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
- return false;
- }
-
- public ResultSet getProcedures(
- final String catalog,
- final String schemaPattern,
- final String procedureNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getProcedures(connection.handle, catalog, pat(schemaPattern),
- pat(procedureNamePattern)),
- new QueryState(MetaDataOperation.GET_PROCEDURES, catalog, schemaPattern,
- procedureNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getProcedureColumns(
- final String catalog,
- final String schemaPattern,
- final String procedureNamePattern,
- final String columnNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getProcedureColumns(connection.handle, catalog,
- pat(schemaPattern), pat(procedureNamePattern), pat(columnNamePattern)),
- new QueryState(MetaDataOperation.GET_PROCEDURE_COLUMNS, catalog, schemaPattern,
- procedureNamePattern, columnNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getTables(
- final String catalog,
- final String schemaPattern,
- final String tableNamePattern,
- final String[] types) throws SQLException {
- final List<String> typeList = types == null ? null : Arrays.asList(types);
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getTables(connection.handle, catalog, pat(schemaPattern),
- pat(tableNamePattern), typeList),
- new QueryState(MetaDataOperation.GET_TABLES, catalog, schemaPattern,
- tableNamePattern, types));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- private static Meta.Pat pat(String schemaPattern) {
- return Meta.Pat.of(schemaPattern);
- }
-
- public ResultSet getSchemas(
- final String catalog, final String schemaPattern) throws SQLException {
- // TODO: add a 'catch ... throw new SQLException' logic to this and other
- // getXxx methods. Right now any error will throw a RuntimeException
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getSchemas(connection.handle, catalog, pat(schemaPattern)),
- new QueryState(MetaDataOperation.GET_SCHEMAS_WITH_ARGS, catalog,
- schemaPattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getSchemas() throws SQLException {
- return getSchemas(null, null);
- }
-
- public ResultSet getCatalogs() throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(connection.meta.getCatalogs(connection.handle),
- new QueryState(MetaDataOperation.GET_CATALOGS));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getTableTypes() throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(connection.meta.getTableTypes(connection.handle),
- new QueryState(MetaDataOperation.GET_TABLE_TYPES));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getColumns(
- final String catalog,
- final String schemaPattern,
- final String tableNamePattern,
- final String columnNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getColumns(connection.handle, catalog, pat(schemaPattern),
- pat(tableNamePattern), pat(columnNamePattern)),
- new QueryState(MetaDataOperation.GET_COLUMNS, catalog, schemaPattern,
- tableNamePattern, columnNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getColumnPrivileges(
- final String catalog,
- final String schema,
- final String table,
- final String columnNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getColumnPrivileges(connection.handle, catalog, schema, table,
- pat(columnNamePattern)),
- new QueryState(MetaDataOperation.GET_COLUMN_PRIVILEGES, catalog, schema, table,
- columnNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getTablePrivileges(
- final String catalog,
- final String schemaPattern,
- final String tableNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getTablePrivileges(connection.handle, catalog,
- pat(schemaPattern), pat(tableNamePattern)),
- new QueryState(MetaDataOperation.GET_TABLE_PRIVILEGES, catalog, schemaPattern,
- tableNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getBestRowIdentifier(
- final String catalog,
- final String schema,
- final String table,
- final int scope,
- final boolean nullable) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getBestRowIdentifier(connection.handle, catalog, schema, table,
- scope, nullable),
- new QueryState(MetaDataOperation.GET_BEST_ROW_IDENTIFIER, catalog, table, scope,
- nullable));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getVersionColumns(
- final String catalog, final String schema, final String table) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getVersionColumns(connection.handle, catalog, schema, table),
- new QueryState(MetaDataOperation.GET_VERSION_COLUMNS, catalog, schema, table));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getPrimaryKeys(
- final String catalog, final String schema, final String table) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getPrimaryKeys(connection.handle, catalog, schema, table),
- new QueryState(MetaDataOperation.GET_PRIMARY_KEYS, catalog, schema, table));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getImportedKeys(
- final String catalog, final String schema, final String table) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getImportedKeys(connection.handle, catalog, schema, table),
- new QueryState(MetaDataOperation.GET_IMPORTED_KEYS, catalog, schema, table));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getExportedKeys(
- final String catalog, final String schema, final String table) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getExportedKeys(connection.handle, catalog, schema, table),
- new QueryState(MetaDataOperation.GET_EXPORTED_KEYS, catalog, schema, table));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getCrossReference(
- final String parentCatalog,
- final String parentSchema,
- final String parentTable,
- final String foreignCatalog,
- final String foreignSchema,
- final String foreignTable) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getCrossReference(connection.handle, parentCatalog,
- parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable),
- new QueryState(MetaDataOperation.GET_CROSS_REFERENCE, parentCatalog,
- parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getTypeInfo() throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(connection.meta.getTypeInfo(connection.handle),
- new QueryState(MetaDataOperation.GET_TYPE_INFO));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getIndexInfo(
- final String catalog,
- final String schema,
- final String table,
- final boolean unique,
- final boolean approximate) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getIndexInfo(connection.handle, catalog, schema, table, unique,
- approximate),
- new QueryState(MetaDataOperation.GET_INDEX_INFO, catalog, schema, table, unique,
- approximate));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public boolean supportsResultSetType(int type) throws SQLException {
- return type == ResultSet.TYPE_FORWARD_ONLY;
- }
-
- public boolean supportsResultSetConcurrency(
- int type, int concurrency) throws SQLException {
- return type == ResultSet.TYPE_FORWARD_ONLY
- && concurrency == ResultSet.CONCUR_READ_ONLY;
- }
-
- public boolean ownUpdatesAreVisible(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean ownDeletesAreVisible(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean ownInsertsAreVisible(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean othersUpdatesAreVisible(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean othersDeletesAreVisible(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean othersInsertsAreVisible(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean updatesAreDetected(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean deletesAreDetected(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean insertsAreDetected(int type) throws SQLException {
- throw connection.helper.todo();
- }
-
- public boolean supportsBatchUpdates() throws SQLException {
- return true;
- }
-
- public ResultSet getUDTs(
- final String catalog,
- final String schemaPattern,
- final String typeNamePattern,
- final int[] types) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getUDTs(connection.handle, catalog, pat(schemaPattern),
- pat(typeNamePattern), types),
- new QueryState(MetaDataOperation.GET_UDTS, catalog, schemaPattern,
- typeNamePattern, types));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public Connection getConnection() throws SQLException {
- return connection;
- }
-
- public boolean supportsSavepoints() throws SQLException {
- return false;
- }
-
- public boolean supportsNamedParameters() throws SQLException {
- return false;
- }
-
- public boolean supportsMultipleOpenResults() throws SQLException {
- return false;
- }
-
- public boolean supportsGetGeneratedKeys() throws SQLException {
- return false;
- }
-
- public ResultSet getSuperTypes(
- final String catalog,
- final String schemaPattern,
- final String typeNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getSuperTypes(connection.handle, catalog, pat(schemaPattern),
- pat(typeNamePattern)),
- new QueryState(MetaDataOperation.GET_SUPER_TYPES, catalog, schemaPattern,
- typeNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getSuperTables(
- final String catalog,
- final String schemaPattern,
- final String tableNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getSuperTables(connection.handle, catalog, pat(schemaPattern),
- pat(tableNamePattern)),
- new QueryState(MetaDataOperation.GET_SUPER_TABLES, catalog, schemaPattern,
- tableNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getAttributes(
- final String catalog,
- final String schemaPattern,
- final String typeNamePattern,
- final String attributeNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getAttributes(connection.handle, catalog, pat(schemaPattern),
- pat(typeNamePattern), pat(attributeNamePattern)),
- new QueryState(MetaDataOperation.GET_ATTRIBUTES, catalog, schemaPattern,
- typeNamePattern, attributeNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public boolean supportsResultSetHoldability(int holdability)
- throws SQLException {
- throw connection.helper.todo();
- }
-
- public int getResultSetHoldability() {
- return ResultSet.HOLD_CURSORS_OVER_COMMIT;
- }
-
- public int getDatabaseMajorVersion() throws SQLException {
- return connection.driver.version.databaseMajorVersion;
- }
-
- public int getDatabaseMinorVersion() throws SQLException {
- return connection.driver.version.databaseMinorVersion;
- }
-
- public int getJDBCMajorVersion() throws SQLException {
- return connection.factory.getJdbcMajorVersion();
- }
-
- public int getJDBCMinorVersion() throws SQLException {
- return connection.factory.getJdbcMinorVersion();
- }
-
- public int getSQLStateType() throws SQLException {
- return sqlStateSQL;
- }
-
- public boolean locatorsUpdateCopy() throws SQLException {
- return true;
- }
-
- public boolean supportsStatementPooling() throws SQLException {
- return false;
- }
-
- public RowIdLifetime getRowIdLifetime() throws SQLException {
- return RowIdLifetime.ROWID_UNSUPPORTED;
- }
-
- public boolean supportsStoredFunctionsUsingCallSyntax()
- throws SQLException {
- return true;
- }
-
- public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
- return false;
- }
-
- public ResultSet getClientInfoProperties() throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getClientInfoProperties(connection.handle),
- new QueryState(MetaDataOperation.GET_CLIENT_INFO_PROPERTIES));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getFunctions(
- final String catalog,
- final String schemaPattern,
- final String functionNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getFunctions(connection.handle, catalog, pat(schemaPattern),
- pat(functionNamePattern)),
- new QueryState(MetaDataOperation.GET_FUNCTIONS, catalog, schemaPattern,
- functionNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getFunctionColumns(
- final String catalog,
- final String schemaPattern,
- final String functionNamePattern,
- final String columnNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getFunctionColumns(connection.handle, catalog,
- pat(schemaPattern), pat(functionNamePattern), pat(columnNamePattern)),
- new QueryState(MetaDataOperation.GET_FUNCTION_COLUMNS, catalog,
- schemaPattern, functionNamePattern, columnNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public ResultSet getPseudoColumns(
- final String catalog,
- final String schemaPattern,
- final String tableNamePattern,
- final String columnNamePattern) throws SQLException {
- try {
- return connection.invokeWithRetries(
- new CallableWithoutException<ResultSet>() {
- public ResultSet call() {
- try {
- return connection.createResultSet(
- connection.meta.getPseudoColumns(connection.handle, catalog, pat(schemaPattern),
- pat(tableNamePattern), pat(columnNamePattern)),
- new QueryState(MetaDataOperation.GET_PSEUDO_COLUMNS, catalog, schemaPattern,
- tableNamePattern, columnNamePattern));
- } catch (SQLException e) {
- throw new RuntimeException(e);
- }
- }
- });
- } catch (RuntimeException e) {
- Throwable cause = e.getCause();
- if (cause instanceof SQLException) {
- throw (SQLException) cause;
- }
- throw e;
- }
- }
-
- public boolean generatedKeyAlwaysReturned() throws SQLException {
- return false;
- }
-
- // implement Wrapper
-
- @Override public <T> T unwrap(Class<T> iface) throws SQLException {
- if (iface.isInstance(this)) {
- return iface.cast(this);
- }
-
- if (Properties.class.equals(iface)) {
- return iface.cast(getRemoteAvaticaProperties());
- }
-
- throw connection.helper.createException(
- "does not implement '" + iface + "'");
- }
-
- @Override public boolean isWrapperFor(Class<?> iface) throws SQLException {
- return iface.isInstance(this) || Properties.class.equals(iface);
- }
-
- // Not JDBC Methods
-
- @Override public Properties getRemoteAvaticaProperties() {
- Map<DatabaseProperty, Object> propertyMap = connection.invokeWithRetries(
- new CallableWithoutException<Map<DatabaseProperty, Object>>() {
- public Map<DatabaseProperty, Object> call() {
- return connection.meta.getDatabaseProperties(connection.handle);
- }
- });
-
- final Properties properties = new Properties();
- for (Entry<DatabaseProperty, Object> entry: propertyMap.entrySet()) {
- properties.setProperty(entry.getKey().name(), entry.getValue().toString());
- }
-
- return properties;
- }
-
- /**
- * Fetches the Avatica version from the given server.
- *
- * @return The Avatica version string or null if the server did not provide the version.
- */
- @Override public String getAvaticaServerVersion() {
- Map<DatabaseProperty, Object> properties = connection.invokeWithRetries(
- new CallableWithoutException<Map<DatabaseProperty, Object>>() {
- public Map<DatabaseProperty, Object> call() {
- return connection.meta.getDatabaseProperties(connection.handle);
- }
- });
- Object o = properties.get(DatabaseProperty.AVATICA_VERSION);
- if (null == o) {
- return null;
- }
- return (String) o;
- }
-}
-
-// End AvaticaDatabaseMetaData.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/5289d343/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaFactory.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaFactory.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaFactory.java
deleted file mode 100644
index f6d955e..0000000
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaFactory.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * 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.calcite.avatica;
-
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
-import java.util.Properties;
-import java.util.TimeZone;
-
-/**
- * Factory for JDBC objects.
- *
- * <p>There is an implementation for each supported JDBC version.</p>
- */
-public interface AvaticaFactory {
- int getJdbcMajorVersion();
-
- int getJdbcMinorVersion();
-
- AvaticaConnection newConnection(
- UnregisteredDriver driver,
- AvaticaFactory factory,
- String url,
- Properties info) throws SQLException;
-
- AvaticaStatement newStatement(AvaticaConnection connection,
- /*@Nullable*/ Meta.StatementHandle h, int resultSetType,
- int resultSetConcurrency, int resultSetHoldability) throws SQLException;
-
- AvaticaPreparedStatement newPreparedStatement(AvaticaConnection connection,
- /*@Nullable*/ Meta.StatementHandle h, Meta.Signature signature,
- int resultSetType, int resultSetConcurrency, int resultSetHoldability)
- throws SQLException;
-
- /**
- * Creates a result set. You will then need to call
- * {@link AvaticaResultSet#execute()} on it.
- *
- * @param statement Statement
- * @param state The state used to create this result set
- * @param signature Prepared statement
- * @param timeZone Time zone
- * @param firstFrame Frame containing the first (or perhaps only) rows in the
- * result, or null if an execute/fetch is required
- * @return Result set
- */
- AvaticaResultSet newResultSet(AvaticaStatement statement, QueryState state,
- Meta.Signature signature, TimeZone timeZone, Meta.Frame firstFrame)
- throws SQLException;
-
- /**
- * Creates meta data for the database.
- *
- * @return Database meta data
- */
- AvaticaSpecificDatabaseMetaData newDatabaseMetaData(AvaticaConnection connection);
-
- /**
- * Creates meta data for a result set.
- *
- * @param statement Statement
- * @param signature Prepared statement
- * @return Result set meta data
- */
- ResultSetMetaData newResultSetMetaData(AvaticaStatement statement,
- Meta.Signature signature) throws SQLException;
-}
-
-// End AvaticaFactory.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/5289d343/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaJdbc41Factory.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaJdbc41Factory.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaJdbc41Factory.java
deleted file mode 100644
index 2edf515..0000000
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaJdbc41Factory.java
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * 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.calcite.avatica;
-
-import java.io.InputStream;
-import java.io.Reader;
-import java.sql.NClob;
-import java.sql.ResultSetMetaData;
-import java.sql.RowId;
-import java.sql.SQLException;
-import java.sql.SQLXML;
-import java.util.Properties;
-import java.util.TimeZone;
-
-/**
- * Implementation of {@link AvaticaFactory} for JDBC 4.1 (corresponds to JDK
- * 1.7).
- */
-@SuppressWarnings("UnusedDeclaration")
-class AvaticaJdbc41Factory implements AvaticaFactory {
- private final int major;
- private final int minor;
-
- /** Creates a JDBC factory. */
- public AvaticaJdbc41Factory() {
- this(4, 1);
- }
-
- /** Creates a JDBC factory with given major/minor version number. */
- protected AvaticaJdbc41Factory(int major, int minor) {
- this.major = major;
- this.minor = minor;
- }
-
- public int getJdbcMajorVersion() {
- return major;
- }
-
- public int getJdbcMinorVersion() {
- return minor;
- }
-
- public AvaticaConnection newConnection(
- UnregisteredDriver driver,
- AvaticaFactory factory,
- String url,
- Properties info) {
- return new AvaticaJdbc41Connection(driver, factory, url, info);
- }
-
- public AvaticaSpecificDatabaseMetaData newDatabaseMetaData(
- AvaticaConnection connection) {
- return new AvaticaJdbc41DatabaseMetaData(connection);
- }
-
- public AvaticaStatement newStatement(AvaticaConnection connection,
- Meta.StatementHandle h, int resultSetType, int resultSetConcurrency,
- int resultSetHoldability) {
- return new AvaticaJdbc41Statement(connection, h, resultSetType,
- resultSetConcurrency, resultSetHoldability);
- }
-
- public AvaticaPreparedStatement newPreparedStatement(
- AvaticaConnection connection, Meta.StatementHandle h,
- Meta.Signature signature, int resultSetType, int resultSetConcurrency,
- int resultSetHoldability)
- throws SQLException {
- return new AvaticaJdbc41PreparedStatement(connection, h, signature,
- resultSetType, resultSetConcurrency, resultSetHoldability);
- }
-
- public AvaticaResultSet newResultSet(AvaticaStatement statement,
- QueryState state, Meta.Signature signature, TimeZone timeZone, Meta.Frame firstFrame) {
- final ResultSetMetaData metaData =
- newResultSetMetaData(statement, signature);
- return new AvaticaResultSet(statement, state, signature, metaData, timeZone,
- firstFrame);
- }
-
- public AvaticaResultSetMetaData newResultSetMetaData(
- AvaticaStatement statement, Meta.Signature signature) {
- return new AvaticaResultSetMetaData(statement, null, signature);
- }
-
- /** Implementation of Connection for JDBC 4.1. */
- private static class AvaticaJdbc41Connection extends AvaticaConnection {
- AvaticaJdbc41Connection(UnregisteredDriver driver,
- AvaticaFactory factory,
- String url,
- Properties info) {
- super(driver, factory, url, info);
- }
- }
-
- /** Implementation of Statement for JDBC 4.1. */
- private static class AvaticaJdbc41Statement extends AvaticaStatement {
- public AvaticaJdbc41Statement(AvaticaConnection connection,
- Meta.StatementHandle h, int resultSetType, int resultSetConcurrency,
- int resultSetHoldability) {
- super(connection, h, resultSetType, resultSetConcurrency,
- resultSetHoldability);
- }
- }
-
- /** Implementation of PreparedStatement for JDBC 4.1. */
- private static class AvaticaJdbc41PreparedStatement
- extends AvaticaPreparedStatement {
- AvaticaJdbc41PreparedStatement(AvaticaConnection connection,
- Meta.StatementHandle h, Meta.Signature signature, int resultSetType,
- int resultSetConcurrency, int resultSetHoldability)
- throws SQLException {
- super(connection, h, signature, resultSetType, resultSetConcurrency,
- resultSetHoldability);
- }
-
- public void setRowId(
- int parameterIndex,
- RowId x) throws SQLException {
- getSite(parameterIndex).setRowId(x);
- }
-
- public void setNString(
- int parameterIndex, String value) throws SQLException {
- getSite(parameterIndex).setNString(value);
- }
-
- public void setNCharacterStream(
- int parameterIndex,
- Reader value,
- long length) throws SQLException {
- getSite(parameterIndex)
- .setNCharacterStream(value, length);
- }
-
- public void setNClob(
- int parameterIndex,
- NClob value) throws SQLException {
- getSite(parameterIndex).setNClob(value);
- }
-
- public void setClob(
- int parameterIndex,
- Reader reader,
- long length) throws SQLException {
- getSite(parameterIndex)
- .setClob(reader, length);
- }
-
- public void setBlob(
- int parameterIndex,
- InputStream inputStream,
- long length) throws SQLException {
- getSite(parameterIndex)
- .setBlob(inputStream, length);
- }
-
- public void setNClob(
- int parameterIndex,
- Reader reader,
- long length) throws SQLException {
- getSite(parameterIndex)
- .setNClob(reader, length);
- }
-
- public void setSQLXML(
- int parameterIndex, SQLXML xmlObject) throws SQLException {
- getSite(parameterIndex).setSQLXML(xmlObject);
- }
-
- public void setAsciiStream(
- int parameterIndex,
- InputStream x,
- long length) throws SQLException {
- getSite(parameterIndex)
- .setAsciiStream(x, length);
- }
-
- public void setBinaryStream(
- int parameterIndex,
- InputStream x,
- long length) throws SQLException {
- getSite(parameterIndex)
- .setBinaryStream(x, length);
- }
-
- public void setCharacterStream(
- int parameterIndex,
- Reader reader,
- long length) throws SQLException {
- getSite(parameterIndex)
- .setCharacterStream(reader, length);
- }
-
- public void setAsciiStream(
- int parameterIndex, InputStream x) throws SQLException {
- getSite(parameterIndex).setAsciiStream(x);
- }
-
- public void setBinaryStream(
- int parameterIndex, InputStream x) throws SQLException {
- getSite(parameterIndex).setBinaryStream(x);
- }
-
- public void setCharacterStream(
- int parameterIndex, Reader reader) throws SQLException {
- getSite(parameterIndex)
- .setCharacterStream(reader);
- }
-
- public void setNCharacterStream(
- int parameterIndex, Reader value) throws SQLException {
- getSite(parameterIndex)
- .setNCharacterStream(value);
- }
-
- public void setClob(
- int parameterIndex,
- Reader reader) throws SQLException {
- getSite(parameterIndex).setClob(reader);
- }
-
- public void setBlob(
- int parameterIndex, InputStream inputStream) throws SQLException {
- getSite(parameterIndex).setBlob(inputStream);
- }
-
- public void setNClob(
- int parameterIndex, Reader reader) throws SQLException {
- getSite(parameterIndex).setNClob(reader);
- }
- }
-
- /** Implementation of DatabaseMetaData for JDBC 4.1. */
- private static class AvaticaJdbc41DatabaseMetaData
- extends AvaticaDatabaseMetaData {
- AvaticaJdbc41DatabaseMetaData(AvaticaConnection connection) {
- super(connection);
- }
- }
-}
-
-// End AvaticaJdbc41Factory.java