How to use

EventSchema

in

org.axonframework.eventsourcing.eventstore.jdbc

  /**
   * Builds a new {@link EventSchema} from builder values.
   *
   * @return new EventSchema
   */
  public EventSchema build() {
    return new EventSchema(this);
  }
}

@Override
public PreparedStatement createDomainEventTable(Connection connection,
                        EventSchema schema) throws SQLException {
  String sql = "CREATE TABLE IF NOT EXISTS " + schema.domainEventTable() + " (\n" +
      schema.globalIndexColumn() + " " + idColumnType() + " NOT NULL,\n" +
      schema.aggregateIdentifierColumn() + " VARCHAR(255) NOT NULL,\n" +
      schema.sequenceNumberColumn() + " BIGINT NOT NULL,\n" +
      schema.typeColumn() + " VARCHAR(255),\n" +
      schema.eventIdentifierColumn() + " VARCHAR(255) NOT NULL,\n" +
      schema.metaDataColumn() + " " + payloadType() + ",\n" +
      schema.payloadColumn() + " " + payloadType() + " NOT NULL,\n" +
      schema.payloadRevisionColumn() + " VARCHAR(255),\n" +
      schema.payloadTypeColumn() + " VARCHAR(255) NOT NULL,\n" +
      schema.timestampColumn() + " VARCHAR(255) NOT NULL,\n" +
      "PRIMARY KEY (" + schema.globalIndexColumn() + "),\n" +
      "UNIQUE (" + schema.aggregateIdentifierColumn() + ", " +
      schema.sequenceNumberColumn() + "),\n" +
      "UNIQUE (" + schema.eventIdentifierColumn() + ")\n" +
      ")";
  return connection.prepareStatement(sql);
}

/**
 * Creates a statement to delete all snapshots of the aggregate with given {@code aggregateIdentifier}.
 *
 * @param connection          The connection to the database.
 * @param aggregateIdentifier The identifier of the aggregate whose snapshots to delete.
 * @return A {@link PreparedStatement} that deletes all the aggregate's snapshots when executed.
 *
 * @throws SQLException when an exception occurs while creating the prepared statement.
 */
protected PreparedStatement deleteSnapshots(Connection connection, String aggregateIdentifier, long sequenceNumber)
    throws SQLException {
  PreparedStatement preparedStatement = connection.prepareStatement(
      "DELETE FROM " + schema.snapshotTable() + " WHERE " + schema.aggregateIdentifierColumn() + " = ? "
          + "AND " + schema.sequenceNumberColumn() + " < ?"
  );
  preparedStatement.setString(1, aggregateIdentifier);
  preparedStatement.setLong(2, sequenceNumber);
  return preparedStatement;
}

/**
 * Returns a comma separated list of domain event column names to select from an event or snapshot entry.
 *
 * @return comma separated domain event column names.
 */
protected String domainEventFields() {
  return String.join(", ", schema.eventIdentifierColumn(), schema.timestampColumn(), schema.payloadTypeColumn(),
            schema.payloadRevisionColumn(), schema.payloadColumn(), schema.metaDataColumn(),
            schema.typeColumn(), schema.aggregateIdentifierColumn(), schema.sequenceNumberColumn());
}

/**
 * Creates a statement to read domain event entries for an aggregate with given identifier starting with the first
 * entry having a sequence number that is equal or larger than the given {@code firstSequenceNumber}.
 *
 * @param connection          The connection to the database.
 * @param identifier          The identifier of the aggregate.
 * @param firstSequenceNumber The expected sequence number of the first returned entry.
 * @param batchSize           The number of items to include in the batch
 * @return A {@link PreparedStatement} that returns event entries for the given query when executed.
 *
 * @throws SQLException when an exception occurs while creating the prepared statement.
 */
protected PreparedStatement readEventData(Connection connection, String identifier,
                     long firstSequenceNumber, int batchSize) throws SQLException {
  Transaction tx = transactionManager.startTransaction();
  try {
    final String sql = "SELECT " + trackedEventFields() + " FROM " + schema.domainEventTable() + " WHERE " +
        schema.aggregateIdentifierColumn() + " = ? AND " + schema.sequenceNumberColumn() + " >= ? AND " +
        schema.sequenceNumberColumn() + " < ? ORDER BY " + schema.sequenceNumberColumn() + " ASC";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    preparedStatement.setString(1, identifier);
    preparedStatement.setLong(2, firstSequenceNumber);
    preparedStatement.setLong(3, firstSequenceNumber + batchSize);
    return preparedStatement;
  } finally {
    tx.commit();
  }
}

@Override
public TrackingToken createTailToken() {
  String sql = "SELECT min(" + schema.globalIndexColumn() + ") - 1 FROM " + schema.domainEventTable();
  Long index = transactionManager.fetchInTransaction(
      () -> executeQuery(getConnection(),
                connection -> connection.prepareStatement(sql),
                resultSet -> nextAndExtract(resultSet, 1, Long.class),
                e -> new EventStoreException("Failed to get tail token", e)));
  return Optional.ofNullable(index)
          .map(seq -> GapAwareTrackingToken.newInstance(seq, Collections.emptySet()))
          .orElse(null);
}

PreparedStatement statement =
    conn.prepareStatement(format("SELECT %s, %s FROM %s WHERE %s >= ? AND %s <= ?",
                   schema.globalIndexColumn(),
                   schema.timestampColumn(),
                   schema.domainEventTable(),
                   schema.globalIndexColumn(),
                   schema.globalIndexColumn()));
statement.setLong(1, gaps.first());
statement.setLong(2, gaps.last() + 1L);
while (resultSet.next()) {
  try {
    long sequenceNumber = resultSet.getLong(schema.globalIndexColumn());
    Instant timestamp =
        DateTimeUtils.parseInstant(readTimeStamp(resultSet, schema.timestampColumn()).toString());
    if (gaps.contains(sequenceNumber) || timestamp.isAfter(gapTimeoutFrame())) {

@Test
public void testCreateDomainEventTable() throws Exception {
  // test passes if no exception is thrown
  testSubject.createDomainEventTable(connection, eventSchema)
      .execute();
  connection.prepareStatement("SELECT * FROM " + eventSchema.domainEventTable())
      .execute();
  connection.prepareStatement("DROP TABLE " + eventSchema.domainEventTable())
      .execute();
  connection.prepareStatement("DROP SEQUENCE " + eventSchema.domainEventTable() + "_seq")
      .execute();
}

  @Test
  public void testCreateSnapshotEventTable() throws Exception {
    // test passes if no exception is thrown
    testSubject.createSnapshotEventTable(connection, eventSchema)
        .execute();
    connection.prepareStatement("SELECT * FROM " + eventSchema.snapshotTable())
        .execute();

    connection.prepareStatement("DROP TABLE " + eventSchema.snapshotTable())
        .execute();
  }
}

/**
 * Returns a comma separated list of tracked domain event column names to select from an event entry.
 *
 * @return comma separated tracked domain event column names.
 */
protected String trackedEventFields() {
  return schema.globalIndexColumn() + ", " + domainEventFields();
}

/**
 * Initializes the default Event Schema
 */
public EventSchema() {
  this(builder());
}

@Override
public TrackingToken createHeadToken() {
  String sql = "SELECT max(" + schema.globalIndexColumn() + ") FROM " + schema.domainEventTable();
  Long index = transactionManager.fetchInTransaction(
      () -> executeQuery(getConnection(),
                connection -> connection.prepareStatement(sql),
                resultSet -> nextAndExtract(resultSet, 1, Long.class),
                e -> new EventStoreException("Failed to get head token", e)));
  return Optional.ofNullable(index)
          .map(seq -> GapAwareTrackingToken.newInstance(seq, Collections.emptySet()))
          .orElse(null);
}

@Override
public Optional<Long> lastSequenceNumberFor(String aggregateIdentifier) {
  String sql = "SELECT max(" + schema.sequenceNumberColumn() + ") FROM " + schema.domainEventTable() +
      " WHERE " + schema.aggregateIdentifierColumn() + " = ?";
  return Optional.ofNullable(transactionManager.fetchInTransaction(
      () -> executeQuery(getConnection(), connection -> {
                  PreparedStatement stmt = connection.prepareStatement(sql);
                  stmt.setString(1, aggregateIdentifier);
                  return stmt;
                },
                resultSet -> nextAndExtract(resultSet, 1, Long.class),
                e -> new EventStoreException(
                    format("Failed to read events for aggregate [%s]", aggregateIdentifier), e
                )
      )));
}

@Override
public TrackingToken createTokenAt(Instant dateTime) {
  String sql = "SELECT min(" + schema.globalIndexColumn() + ") - 1 FROM " + schema.domainEventTable() + " WHERE "
      + schema.timestampColumn() + " >= ?";
  Long index = transactionManager.fetchInTransaction(
      () -> executeQuery(getConnection(),
                connection -> {
                  PreparedStatement stmt = connection.prepareStatement(sql);
                  stmt.setString(1, formatInstant(dateTime));
                  return stmt;
                },
                resultSet -> nextAndExtract(resultSet, 1, Long.class),
                e -> new EventStoreException(format("Failed to get token at [%s]", dateTime), e)));
  if (index == null) {
    return null;
  }
  return GapAwareTrackingToken.newInstance(index, Collections.emptySet());
}

/**
 * Returns a comma separated list of tracked domain event column names to select from an event entry.
 *
 * @return comma separated tracked domain event column names.
 */
protected String trackedEventFields() {
  return schema.globalIndexColumn() + ", " + domainEventFields();
}

/**
 * Initializes the default Event Schema
 */
public EventSchema() {
  this(builder());
}

@Override
public PreparedStatement createSnapshotEventTable(Connection connection, EventSchema schema) throws SQLException {
  String sql = "CREATE TABLE " + schema.snapshotTable() + " (\n" +
      schema.aggregateIdentifierColumn() + " VARCHAR(255) NOT NULL,\n" +
      schema.sequenceNumberColumn() + " NUMBER(19) NOT NULL,\n" +
      schema.typeColumn() + " VARCHAR(255) NOT NULL,\n" +
      schema.eventIdentifierColumn() + " VARCHAR(255) NOT NULL,\n" +
      schema.metaDataColumn() + " " + payloadType() + ",\n" +
      schema.payloadColumn() + " " + payloadType() + " NOT NULL,\n" +
      schema.payloadRevisionColumn() + " VARCHAR(255),\n" +
      schema.payloadTypeColumn() + " VARCHAR(255) NOT NULL,\n" +
      schema.timestampColumn() + " VARCHAR(255) NOT NULL,\n" +
      "PRIMARY KEY (" + schema.aggregateIdentifierColumn() + ", " +
      schema.sequenceNumberColumn() + "),\n" +
      "UNIQUE (" + schema.eventIdentifierColumn() + ")\n" +
      ")";
  return connection.prepareStatement(sql);
}

    () -> format("Token [%s] is of the wrong type", lastToken));
GapAwareTrackingToken previousToken = (GapAwareTrackingToken) lastToken;
String sql = "SELECT " + trackedEventFields() + " FROM " + schema.domainEventTable() +
    " WHERE (" + schema.globalIndexColumn() + " > ? AND " + schema.globalIndexColumn() + " <= ?) ";
List<Long> gaps;
if (previousToken != null) {
  gaps = new ArrayList<>(previousToken.getGaps());
  if (!gaps.isEmpty()) {
    sql += " OR " + schema.globalIndexColumn() + " IN (" +
        String.join(",", Collections.nCopies(gaps.size(), "?")) + ") ";
  gaps = Collections.emptyList();
sql += "ORDER BY " + schema.globalIndexColumn() + " ASC";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
long globalIndex = previousToken == null ? -1 : previousToken.getIndex();

/**
 * Creates a statement to read the snapshot entry of an aggregate with given identifier.
 *
 * @param connection The connection to the database.
 * @param identifier The aggregate identifier.
 * @return A {@link PreparedStatement} that returns the last snapshot entry of the aggregate (if any) when executed.
 *
 * @throws SQLException when an exception occurs while creating the prepared statement.
 */
protected PreparedStatement readSnapshotData(Connection connection, String identifier) throws SQLException {
  final String s = "SELECT " + domainEventFields() + " FROM " + schema.snapshotTable() + " WHERE " +
      schema.aggregateIdentifierColumn() + " = ? ORDER BY " + schema.sequenceNumberColumn() + " DESC";
  PreparedStatement statement = connection.prepareStatement(s);
  statement.setString(1, identifier);
  return statement;
}

/**
 * Creates a statement to read domain event entries for an aggregate with given identifier starting with the first
 * entry having a sequence number that is equal or larger than the given {@code firstSequenceNumber}.
 *
 * @param connection          The connection to the database.
 * @param identifier          The identifier of the aggregate.
 * @param firstSequenceNumber The expected sequence number of the first returned entry.
 * @param batchSize           The number of items to include in the batch
 * @return A {@link PreparedStatement} that returns event entries for the given query when executed.
 * @throws SQLException when an exception occurs while creating the prepared statement.
 */
protected PreparedStatement readEventData(Connection connection, String identifier,
                     long firstSequenceNumber, int batchSize) throws SQLException {
  Transaction tx = transactionManager.startTransaction();
  try {
    final String sql = "SELECT " + trackedEventFields() + " FROM " + schema.domainEventTable() + " WHERE " +
        schema.aggregateIdentifierColumn() + " = ? AND " + schema.sequenceNumberColumn() + " >= ? AND " +
        schema.sequenceNumberColumn() + " < ? ORDER BY " + schema.sequenceNumberColumn() + " ASC";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    preparedStatement.setString(1, identifier);
    preparedStatement.setLong(2, firstSequenceNumber);
    preparedStatement.setLong(3, firstSequenceNumber + batchSize);
    return preparedStatement;
  } finally {
    tx.commit();
  }
}