org.apache.calcite.avatica.ConnectionPropertiesImpl Java Examples

@Override
public ConnectionProperties connectionSync(ConnectionHandle ch,
    ConnectionProperties connProps) {
    LOGGER.trace("syncing properties for connection {}", ch);
    try {
        Connection conn = getConnection(ch.id);
        ConnectionPropertiesImpl props = new ConnectionPropertiesImpl().merge(connProps);
        if (props.isDirty()) {
            apply(conn, props);
            props.setDirty(false);
        }
        return props;
    } catch (SQLException e) {
        throw propagate(e);
    }
}
 

@Override ConnectionSyncRequest deserialize(Message genericMsg) {
  final Requests.ConnectionSyncRequest msg = ProtobufService.castProtobufMessage(genericMsg,
      Requests.ConnectionSyncRequest.class);

  String connectionId = null;
  if (msg.hasField(CONNECTION_ID_DESCRIPTOR)) {
    connectionId = msg.getConnectionId();
  }

  Meta.ConnectionProperties connProps = null;
  if (msg.hasField(CONN_PROPS_DESCRIPTOR)) {
    connProps = ConnectionPropertiesImpl.fromProto(msg.getConnProps());
  }

  return new ConnectionSyncRequest(connectionId, connProps);
}
 

@Override public StatementHandle createStatement(final ConnectionHandle ch) {
  return connection.invokeWithRetries(
      new CallableWithoutException<StatementHandle>() {
        public StatementHandle call() {
          // sync connection state if necessary
          connectionSync(ch, new ConnectionPropertiesImpl());
          final Service.CreateStatementResponse response =
              service.apply(new Service.CreateStatementRequest(ch.id));
          return new StatementHandle(response.connectionId, response.statementId, null);
        }
      });
}
 

@Override public StatementHandle prepare(final ConnectionHandle ch, final String sql,
    final long maxRowCount) {
  return connection.invokeWithRetries(
      new CallableWithoutException<StatementHandle>() {
        public StatementHandle call() {
          connectionSync(ch,
              new ConnectionPropertiesImpl()); // sync connection state if necessary
          final Service.PrepareResponse response = service.apply(
              new Service.PrepareRequest(ch.id, sql, maxRowCount));
          return response.statement;
        }
      });
}
 

@Override public ConnectionProperties connectionSync(ConnectionHandle ch,
    ConnectionProperties connProps) {
  LOG.trace("syncing properties for connection {}", ch);
  try {
    Connection conn = getConnection(ch.id);
    ConnectionPropertiesImpl props = new ConnectionPropertiesImpl(conn).merge(connProps);
    if (props.isDirty()) {
      apply(conn, props);
      props.setDirty(false);
    }
    return props;
  } catch (SQLException e) {
    throw propagate(e);
  }
}
 

@Test public void testRemoteConnectionProperties() throws Exception {
  ConnectionSpec.getDatabaseLock().lock();
  try (AvaticaConnection conn = (AvaticaConnection) DriverManager.getConnection(url)) {
    String id = conn.id;
    final Map<String, ConnectionPropertiesImpl> m = ((RemoteMeta) getMeta(conn)).propsMap;
    assertFalse("remote connection map should start ignorant", m.containsKey(id));
    // force creating a connection object on the remote side.
    try (final Statement stmt = conn.createStatement()) {
      assertTrue("creating a statement starts a local object.", m.containsKey(id));
      assertTrue(stmt.execute("select count(1) from EMP"));
    }
    Connection remoteConn = getConnection(FullyRemoteJdbcMetaFactory.getInstance(), id);
    final boolean defaultRO = remoteConn.isReadOnly();
    final boolean defaultAutoCommit = remoteConn.getAutoCommit();
    final String defaultCatalog = remoteConn.getCatalog();
    final String defaultSchema = remoteConn.getSchema();
    conn.setReadOnly(!defaultRO);
    assertTrue("local changes dirty local state", m.get(id).isDirty());
    assertEquals("remote connection has not been touched", defaultRO, remoteConn.isReadOnly());
    conn.setAutoCommit(!defaultAutoCommit);
    assertEquals("remote connection has not been touched",
        defaultAutoCommit, remoteConn.getAutoCommit());

    // further interaction with the connection will force a sync
    try (final Statement stmt = conn.createStatement()) {
      assertEquals(!defaultAutoCommit, remoteConn.getAutoCommit());
      assertFalse("local values should be clean", m.get(id).isDirty());
    }
  } finally {
    ConnectionSpec.getDatabaseLock().unlock();
  }
}
 

@Test public void testRemoteConnectionProperties() throws Exception {
  ConnectionSpec.getDatabaseLock().lock();
  try (AvaticaConnection conn = (AvaticaConnection) DriverManager.getConnection(url)) {
    String id = conn.id;
    final Map<String, ConnectionPropertiesImpl> m = ((RemoteMeta) getMeta(conn)).propsMap;
    assertFalse("remote connection map should start ignorant", m.containsKey(id));
    // force creating a connection object on the remote side.
    try (final Statement stmt = conn.createStatement()) {
      assertTrue("creating a statement starts a local object.", m.containsKey(id));
      assertTrue(stmt.execute("select count(1) from EMP"));
    }
    Connection remoteConn = getConnection(FullyRemoteJdbcMetaFactory.getInstance(), id);
    final boolean defaultRO = remoteConn.isReadOnly();
    final boolean defaultAutoCommit = remoteConn.getAutoCommit();
    final String defaultCatalog = remoteConn.getCatalog();
    final String defaultSchema = remoteConn.getSchema();
    conn.setReadOnly(!defaultRO);
    assertTrue("local changes dirty local state", m.get(id).isDirty());
    assertEquals("remote connection has not been touched", defaultRO, remoteConn.isReadOnly());
    conn.setAutoCommit(!defaultAutoCommit);
    assertEquals("remote connection has not been touched",
        defaultAutoCommit, remoteConn.getAutoCommit());

    // further interaction with the connection will force a sync
    try (final Statement stmt = conn.createStatement()) {
      assertEquals(!defaultAutoCommit, remoteConn.getAutoCommit());
      assertFalse("local values should be clean", m.get(id).isDirty());
    }
  } finally {
    ConnectionSpec.getDatabaseLock().unlock();
  }
}
 

@Override ConnectionSyncResponse deserialize(Message genericMsg) {
  final Responses.ConnectionSyncResponse msg = ProtobufService.castProtobufMessage(genericMsg,
      Responses.ConnectionSyncResponse.class);
  RpcMetadataResponse metadata = null;
  if (msg.hasField(METADATA_DESCRIPTOR)) {
    metadata = RpcMetadataResponse.fromProto(msg.getMetadata());
  }

  return new ConnectionSyncResponse(ConnectionPropertiesImpl.fromProto(msg.getConnProps()),
      metadata);
}
 

@Override public StatementHandle createStatement(final ConnectionHandle ch) {
  return connection.invokeWithRetries(
      new CallableWithoutException<StatementHandle>() {
        public StatementHandle call() {
          // sync connection state if necessary
          connectionSync(ch, new ConnectionPropertiesImpl());
          final Service.CreateStatementResponse response =
              service.apply(new Service.CreateStatementRequest(ch.id));
          return new StatementHandle(response.connectionId, response.statementId, null);
        }
      });
}
 

@Override public StatementHandle prepare(final ConnectionHandle ch, final String sql,
    final long maxRowCount) {
  return connection.invokeWithRetries(
      new CallableWithoutException<StatementHandle>() {
        public StatementHandle call() {
          connectionSync(ch,
              new ConnectionPropertiesImpl()); // sync connection state if necessary
          final Service.PrepareResponse response = service.apply(
              new Service.PrepareRequest(ch.id, sql, maxRowCount));
          return response.statement;
        }
      });
}
 

public boolean getAutoCommit() throws SQLException {
    if (meta.connectionSync(handle, new ConnectionPropertiesImpl()).isAutoCommit() == null)
        setAutoCommit(true);
    return super.getAutoCommit();
}
 

public boolean isReadOnly() throws SQLException {
    if (meta.connectionSync(handle, new ConnectionPropertiesImpl()).isReadOnly() == null)
        setReadOnly(true);
    return super.isReadOnly();
}
 

/**
 * Generates a collection of Requests whose serialization will be tested.
 */
private static List<Request> getRequests() {
  LinkedList<Request> requests = new LinkedList<>();

  requests.add(new CatalogsRequest());
  requests.add(new DatabasePropertyRequest());
  requests.add(new SchemasRequest("connectionId", "catalog", "schemaPattern"));
  requests.add(
      new TablesRequest("connectionId", "catalog", "schemaPattern", "tableNamePattern",
          Arrays.asList("STRING", "BOOLEAN", "INT")));
  requests.add(new TableTypesRequest());
  requests.add(
      new ColumnsRequest("connectionId", "catalog", "schemaPattern", "tableNamePattern",
          "columnNamePattern"));
  requests.add(new TypeInfoRequest());
  requests.add(
      new PrepareAndExecuteRequest("connectionId", Integer.MAX_VALUE, "sql",
          Long.MAX_VALUE));
  requests.add(new PrepareRequest("connectionId", "sql", Long.MAX_VALUE));

  List<TypedValue> paramValues =
      Arrays.asList(TypedValue.create(Rep.BOOLEAN.name(), Boolean.TRUE),
          TypedValue.create(Rep.STRING.name(), "string"));
  FetchRequest fetchRequest = new FetchRequest("connectionId", Integer.MAX_VALUE,
      Long.MAX_VALUE, Integer.MAX_VALUE);
  requests.add(fetchRequest);

  requests.add(new CreateStatementRequest("connectionId"));
  requests.add(new CloseStatementRequest("connectionId", Integer.MAX_VALUE));
  Map<String, String> info = new HashMap<>();
  info.put("param1", "value1");
  info.put("param2", "value2");
  requests.add(new OpenConnectionRequest("connectionId", info));
  requests.add(new CloseConnectionRequest("connectionId"));
  requests.add(
      new ConnectionSyncRequest("connectionId",
          new ConnectionPropertiesImpl(Boolean.FALSE, Boolean.FALSE,
              Integer.MAX_VALUE, "catalog", "schema")));

  requests.add(new SyncResultsRequest("connectionId", 12345, getSqlQueryState(), 150));
  requests.add(new SyncResultsRequest("connectionId2", 54321, getMetadataQueryState1(), 0));
  requests.add(new SyncResultsRequest("connectionId3", 5, getMetadataQueryState2(), 10));

  requests.add(new CommitRequest("connectionId"));
  requests.add(new RollbackRequest("connectionId"));

  // ExecuteBatchRequest omitted because of the special protobuf conversion it does

  List<String> commands = Arrays.asList("command1", "command2", "command3");
  requests.add(new PrepareAndExecuteBatchRequest("connectionId", 12345, commands));


  List<ColumnMetaData> columns = Collections.emptyList();
  List<AvaticaParameter> params = Collections.emptyList();
  Meta.CursorFactory cursorFactory = Meta.CursorFactory.create(Style.LIST, Object.class,
      Collections.<String>emptyList());
  Signature signature = Signature.create(columns, "sql", params, cursorFactory,
      Meta.StatementType.SELECT);
  Meta.StatementHandle handle = new Meta.StatementHandle("1234", 1, signature);
  requests.add(new ExecuteRequest(handle, Arrays.<TypedValue>asList((TypedValue) null), 10));
  requests.add(new ExecuteRequest(handle, Arrays.asList(TypedValue.EXPLICIT_NULL), 10));

  return requests;
}
 

/**
 * Generates a collection of Responses whose serialization will be tested.
 */
private static List<Response> getResponses() {
  final RpcMetadataResponse rpcMetadata = new RpcMetadataResponse("localhost:8765");
  LinkedList<Response> responses = new LinkedList<>();

  // Nested classes (Signature, ColumnMetaData, CursorFactory, etc) are implicitly getting tested)

  // Stub out the metadata for a row
  ScalarType arrayComponentType = ColumnMetaData.scalar(Types.INTEGER, "integer", Rep.INTEGER);
  ColumnMetaData arrayColumnMetaData = getArrayColumnMetaData(arrayComponentType, 2, "counts");
  List<ColumnMetaData> columns =
      Arrays.asList(MetaImpl.columnMetaData("str", 0, String.class, true),
          MetaImpl.columnMetaData("count", 1, Integer.class, true),
          arrayColumnMetaData);
  List<AvaticaParameter> params =
      Arrays.asList(
          new AvaticaParameter(false, 10, 0, Types.VARCHAR, "VARCHAR",
              String.class.getName(), "str"));
  Meta.CursorFactory cursorFactory = Meta.CursorFactory.create(Style.LIST, Object.class,
      Arrays.asList("str", "count", "counts"));
  // The row values
  List<Object> rows = new ArrayList<>();
  rows.add(new Object[] {"str_value1", 50, Arrays.asList(1, 2, 3)});
  rows.add(new Object[] {"str_value2", 100, Arrays.asList(1)});

  // Create the signature and frame using the metadata and values
  Signature signature = Signature.create(columns, "sql", params, cursorFactory,
      Meta.StatementType.SELECT);
  Frame frame = Frame.create(Integer.MAX_VALUE, true, rows);

  // And then create a ResultSetResponse
  ResultSetResponse results1 = new ResultSetResponse("connectionId", Integer.MAX_VALUE, true,
      signature, frame, Long.MAX_VALUE, rpcMetadata);
  responses.add(results1);

  responses.add(new CloseStatementResponse(rpcMetadata));

  ConnectionPropertiesImpl connProps = new ConnectionPropertiesImpl(false, true,
      Integer.MAX_VALUE, "catalog", "schema");
  responses.add(new ConnectionSyncResponse(connProps, rpcMetadata));

  responses.add(new OpenConnectionResponse(rpcMetadata));
  responses.add(new CloseConnectionResponse(rpcMetadata));

  responses.add(new CreateStatementResponse("connectionId", Integer.MAX_VALUE, rpcMetadata));

  Map<Meta.DatabaseProperty, Object> propertyMap = new HashMap<>();
  for (Meta.DatabaseProperty prop : Meta.DatabaseProperty.values()) {
    propertyMap.put(prop, prop.defaultValue);
  }
  responses.add(new DatabasePropertyResponse(propertyMap, rpcMetadata));

  responses.add(
      new ExecuteResponse(Arrays.asList(results1, results1, results1), false, rpcMetadata));
  responses.add(new FetchResponse(frame, false, false, rpcMetadata));
  responses.add(new FetchResponse(frame, true, true, rpcMetadata));
  responses.add(new FetchResponse(frame, false, true, rpcMetadata));
  responses.add(
      new PrepareResponse(
          new Meta.StatementHandle("connectionId", Integer.MAX_VALUE, signature),
          rpcMetadata));

  StringWriter sw = new StringWriter();
  new Exception().printStackTrace(new PrintWriter(sw));
  responses.add(
      new ErrorResponse(Collections.singletonList(sw.toString()), "Test Error Message",
          ErrorResponse.UNKNOWN_ERROR_CODE, ErrorResponse.UNKNOWN_SQL_STATE,
          AvaticaSeverity.WARNING, rpcMetadata));

  // No more results, statement not missing
  responses.add(new SyncResultsResponse(false, false, rpcMetadata));
  // Missing statement, no results
  responses.add(new SyncResultsResponse(false, true, rpcMetadata));
  // More results, no missing statement
  responses.add(new SyncResultsResponse(true, false, rpcMetadata));

  // Some tests to make sure ErrorResponse doesn't fail.
  responses.add(new ErrorResponse((List<String>) null, null, 0, null, null, null));
  responses.add(
      new ErrorResponse(Arrays.asList("stacktrace1", "stacktrace2"), null, 0, null, null, null));

  responses.add(new CommitResponse());
  responses.add(new RollbackResponse());

  long[] updateCounts = new long[]{1, 0, 1, 1};
  responses.add(
      new ExecuteBatchResponse("connectionId", 12345, updateCounts, false, rpcMetadata));

  return responses;
}
 

public boolean getAutoCommit() throws SQLException {
    if (meta.connectionSync(handle, new ConnectionPropertiesImpl()).isAutoCommit() == null)
        setAutoCommit(true);
    return super.getAutoCommit();
}
 

public boolean isReadOnly() throws SQLException {
    if (meta.connectionSync(handle, new ConnectionPropertiesImpl()).isReadOnly() == null)
        setReadOnly(true);
    return super.isReadOnly();
}