How to use org.h2.message

/**
 * Write a message with trace level DEBUG to the trace system.
 *
 * @param s the message
 */
public void debug(String s) {
  if (isEnabled(TraceSystem.DEBUG)) {
    traceWriter.write(TraceSystem.DEBUG, module, s, null);
  }
}

/**
 * Write trace information in the form objectName.text.
 *
 * @param text the trace text
 */
protected void debugCode(String text) {
  if (trace.isDebugEnabled()) {
    trace.debugCode(getTraceObjectName() + "." + text);
  }
}

/**
 * Get a SQL exception meaning this feature is not supported.
 *
 * @param message the message
 * @return the SQL exception
 */
protected SQLException unsupported(String message) {
  try {
    throw DbException.getUnsupportedException(message);
  } catch (Exception e) {
    return logAndConvert(e);
  }
}

@Override
public int readLob(long lobId, byte[] hmac, long offset, byte[] buff,
    int off, int length) {
  throw DbException.throwInternalError();
}

/**
 * [Not supported] Checks if unwrap can return an object of this class.
 *
 * @param iface the class
 */
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
  throw DbException.getUnsupportedException("isWrapperFor");
}

@Override
public void checkWritingAllowed() {
  if (readOnly) {
    throw DbException.get(ErrorCode.DATABASE_IS_READ_ONLY);
  }
  if (fileLockMethod == FileLockMethod.SERIALIZED) {
    if (!reconnectChangePending) {
      throw DbException.get(ErrorCode.DATABASE_IS_READ_ONLY);
    }
  }
}

/**
 * Check if the trace level is equal or higher than INFO.
 *
 * @return true if it is
 */
public boolean isInfoEnabled() {
  return isEnabled(TraceSystem.INFO);
}

public Rownum(Prepared prepared) {
  if (prepared == null) {
    throw DbException.throwInternalError();
  }
  this.prepared = prepared;
}

/**
 * Write a message with trace level INFO to the trace system.
 *
 * @param s the message
 */
public void info(String s) {
  if (isEnabled(TraceSystem.INFO)) {
    traceWriter.write(TraceSystem.INFO, module, s, null);
  }
}

/**
 * Write trace information as a method call in the form
 * objectName.methodName().
 *
 * @param methodName the method name
 */
protected void debugCodeCall(String methodName) {
  if (trace.isDebugEnabled()) {
    trace.debugCode(getTraceObjectName() + "." + methodName + "();");
  }
}

private static JdbcSavepoint convertSavepoint(Savepoint savepoint) {
  if (!(savepoint instanceof JdbcSavepoint)) {
    throw DbException.get(ErrorCode.SAVEPOINT_IS_INVALID_1,
        "" + savepoint);
  }
  return (JdbcSavepoint) savepoint;
}

/**
 * Check if the trace level is equal or higher than DEBUG.
 *
 * @return true if it is
 */
public boolean isDebugEnabled() {
  return isEnabled(TraceSystem.DEBUG);
}

private void removeFromLinkedList(CacheObject rec) {
  if (SysProperties.CHECK && rec == head) {
    DbException.throwInternalError("try to remove head");
  }
  rec.cachePrevious.cacheNext = rec.cacheNext;
  rec.cacheNext.cachePrevious = rec.cachePrevious;
  // TODO cache: mystery: why is this required? needs more memory if we
  // don't do this
  rec.cacheNext = null;
  rec.cachePrevious = null;
}

/**
 * Write Java source code with trace level DEBUG to the trace system.
 *
 * @param java the source code
 */
void debugCode(String java) {
  if (isEnabled(TraceSystem.DEBUG)) {
    traceWriter.write(TraceSystem.DEBUG, module, lineSeparator +
        "/**/" + java, null);
  }
}

/**
 * Gets a SQL exception meaning this feature is not supported.
 *
 * @param message what exactly is not supported
 * @return the exception
 */
public static DbException getUnsupportedException(String message) {
  return get(ErrorCode.FEATURE_NOT_SUPPORTED_1, message);
}

public ConditionAndOr(int andOrType, Expression left, Expression right) {
  this.andOrType = andOrType;
  this.left = left;
  this.right = right;
  if (SysProperties.CHECK && (left == null || right == null)) {
    DbException.throwInternalError(left + " " + right);
  }
}

/**
 * Write a message with trace level ERROR to the trace system.
 *
 * @param t the exception
 * @param s the message
 */
public void error(Throwable t, String s) {
  if (isEnabled(TraceSystem.ERROR)) {
    traceWriter.write(TraceSystem.ERROR, module, s, t);
  }
}

/**
 * Write a message with trace level INFO to the trace system.
 *
 * @param t the exception
 * @param s the message
 */
void info(Throwable t, String s) {
  if (isEnabled(TraceSystem.INFO)) {
    traceWriter.write(TraceSystem.INFO, module, s, t);
  }
}

/**
 * Write a message with trace level DEBUG to the trace system.
 * @param t the exception
 * @param s the message
 */
public void debug(Throwable t, String s) {
  if (isEnabled(TraceSystem.DEBUG)) {
    traceWriter.write(TraceSystem.DEBUG, module, s, t);
  }
}

/**
 * Write Java source code with trace level INFO to the trace system.
 *
 * @param java the source code
 */
public void infoCode(String java) {
  if (isEnabled(TraceSystem.INFO)) {
    traceWriter.write(TraceSystem.INFO, module, lineSeparator +
        "/**/" + java, null);
  }
}