Java Code Examples for org.apache.calcite.avatica.Meta#StatementHandle

public CalciteJdbc41Statement newStatement(AvaticaConnection connection,
    Meta.StatementHandle h,
    int resultSetType,
    int resultSetConcurrency,
    int resultSetHoldability) {
  return new CalciteJdbc41Statement(
      (CalciteConnectionImpl) connection,
      h,
      resultSetType, resultSetConcurrency,
      resultSetHoldability);
}
 

@JsonCreator
public ExecuteRequest(
    @JsonProperty("statementHandle") Meta.StatementHandle statementHandle,
    @JsonProperty("parameterValues") List<TypedValue> parameterValues,
    @JsonProperty("maxRowCount") int maxRowCount) {
  this.statementHandle = statementHandle;
  this.parameterValues = parameterValues;
  this.maxRowCount = maxRowCount;
}
 

PrepareResponse finagle(PrepareResponse response) {
  final Meta.StatementHandle statement = finagle(response.statement);
  if (statement == response.statement) {
    return response;
  }
  return new PrepareResponse(statement, rpcMetadata);
}
 

public ExecuteResponse apply(PrepareAndExecuteRequest request) {
  try (final Context ignore = prepareAndExecuteTimer.start()) {
    final Meta.StatementHandle sh =
        new Meta.StatementHandle(request.connectionId, request.statementId, null);
    try {
      final Meta.ExecuteResult executeResult =
          meta.prepareAndExecute(sh, request.sql, request.maxRowCount,
              request.maxRowsInFirstFrame, new Meta.PrepareCallback() {
                @Override public Object getMonitor() {
                  return LocalService.class;
                }

                @Override public void clear() {
                }

                @Override public void assign(Meta.Signature signature,
                    Meta.Frame firstFrame, long updateCount) {
                }

                @Override public void execute() {
                }
              });
      final List<ResultSetResponse> results = new ArrayList<>();
      for (Meta.MetaResultSet metaResultSet : executeResult.resultSets) {
        results.add(toResponse(metaResultSet));
      }
      return new ExecuteResponse(results, false, serverLevelRpcMetadata);
    } catch (NoSuchStatementException e) {
      // The Statement doesn't exist anymore, bubble up this information
      return new ExecuteResponse(null, true, serverLevelRpcMetadata);
    }
  }
}
 

public AvaticaPreparedStatement newPreparedStatement(
    AvaticaConnection connection,
    Meta.StatementHandle h,
    Signature signature,
    int resultSetType,
    int resultSetConcurrency,
    int resultSetHoldability) throws SQLException {
  return new QuickSqlJdbc41PreparedStatement(
      (QuicksqlConnectionImpl) connection, h,
       signature, resultSetType,
      resultSetConcurrency, resultSetHoldability);
}
 

@Override
public QuarkStatement newStatement(AvaticaConnection connection,
                                   Meta.StatementHandle statementHandle,
                                   int resultSetType,
                                   int resultSetConcurrency,
                                   int resultSetHoldability) {
  return new QuarkJdbc41Statement((QuarkConnectionImpl) connection,
      statementHandle,
      resultSetType,
      resultSetConcurrency,
      resultSetHoldability);
}
 

public CalciteServerStatement getStatement(Meta.StatementHandle h)
    throws NoSuchStatementException {
  CalciteServerStatement statement = statementMap.get(h.id);
  if (statement == null) {
    throw new NoSuchStatementException(h);
  }
  return statement;
}
 

public void addStatement(CalciteConnection connection,
    Meta.StatementHandle h) {
  final CalciteConnectionImpl c = (CalciteConnectionImpl) connection;
  final CalciteServerStatement previous =
      statementMap.put(h.id, new CalciteServerStatementImpl(c));
  if (previous != null) {
    throw new AssertionError();
  }
}
 

QuarkJdbc41Statement(QuarkConnectionImpl connection,
                     Meta.StatementHandle h,
                     int resultSetType,
                     int resultSetConcurrency,
                     int resultSetHoldability) {
  super(connection, h, resultSetType, resultSetConcurrency,
      resultSetHoldability);
}
 

public PlanExecutor(Meta.StatementHandle h,
             QuarkConnectionImpl connection,
             Cache<String, Connection> connectionCache,
             long maxRowCount) {
  this.h = h;
  this.connection = connection;
  this.connectionCache = connectionCache;
  this.maxRowCount = maxRowCount;
}
 

public void addStatement(CalciteConnection connection,
    Meta.StatementHandle h) {
  final CalciteConnectionImpl c = (CalciteConnectionImpl) connection;
  final CalciteServerStatement previous =
      statementMap.put(h.id, new CalciteServerStatementImpl(c));
  if (previous != null) {
    throw new AssertionError();
  }
}
 

public void removeStatement(Meta.StatementHandle h) {
  statementMap.remove(h.id);
}
 

@Override public AtomicBoolean getCancelFlag(Meta.StatementHandle handle)
    throws NoSuchStatementException {
  final CalciteServerStatement serverStatement = server.getStatement(handle);
  return ((CalciteServerStatementImpl) serverStatement).cancelFlag;
}
 

public QuarkJdbcStatement getStatement(Meta.StatementHandle h) {
  return statementMap.get(h.id);
}
 

public void addStatement(QuarkConnection connection,
                         Meta.StatementHandle h) {
  final QuarkConnectionImpl c = (QuarkConnectionImpl) connection;
  statementMap.put(h.id, new QuarkJdbcStatementImpl(c));
}
 

/**
 * Creates a CalcitePreparedStatement.
 *
 * @param connection Connection
 * @param h Statement handle
 * @param signature Result of preparing statement
 * @param resultSetType Result set type
 * @param resultSetConcurrency Result set concurrency
 * @param resultSetHoldability Result set holdability
 * @throws SQLException if database error occurs
 */
protected CalcitePreparedStatement(CalciteConnectionImpl connection,
    Meta.StatementHandle h, Meta.Signature signature, int resultSetType,
    int resultSetConcurrency, int resultSetHoldability) throws SQLException {
  super(connection, h, signature, resultSetType, resultSetConcurrency,
      resultSetHoldability);
}
 

/**
 * Creates a CalcitePreparedStatement.
 *
 * @param connection Connection
 * @param h Statement handle
 * @param signature Result of preparing statement
 * @param resultSetType Result set type
 * @param resultSetConcurrency Result set concurrency
 * @param resultSetHoldability Result set holdability
 * @throws SQLException if database error occurs
 */
protected CalcitePreparedStatement(CalciteConnectionImpl connection,
    Meta.StatementHandle h, Meta.Signature signature, int resultSetType,
    int resultSetConcurrency, int resultSetHoldability) throws SQLException {
  super(connection, h, signature, resultSetType, resultSetConcurrency,
      resultSetHoldability);
}
 

/** Returns the statement with a given handle.
 *
 * @param h Statement handle
 * @return Statement, never null
 * @throws NoSuchStatementException if handle does not represent a statement
 */
CalciteServerStatement getStatement(Meta.StatementHandle h)
    throws NoSuchStatementException;
 

void addStatement(CalciteConnection connection, Meta.StatementHandle h); 

void removeStatement(Meta.StatementHandle h);