Quantity  *Operand     `parser:" @@ \",\""`
	Timestamp *PrimaryTerm `parser:" @@ \")\""`
}

// DateDiffFunc represents the DATE_DIFF function
type DateDiffFunc struct {
	DatePart   string       `parser:" \"DATE_DIFF\" \"(\" @( \"YEAR\":Timeword | \"MONTH\":Timeword | \"DAY\":Timeword | \"HOUR\":Timeword | \"MINUTE\":Timeword | \"SECOND\":Timeword ) \",\" "`
	Timestamp1 *PrimaryTerm `parser:" @@ \",\" "`

	}

	boolV, ok1b := v.ToBool()
	boolA, ok2b := a.ToBool()
	if ok1b && ok2b {
		return boolCompare(op, boolV, boolA)
	}

	timestampV, ok1t := v.ToTimestamp()
	timestampA, ok2t := a.ToTimestamp()
	if ok1t && ok2t {
		return timestampCompare(op, timestampV, timestampA), nil
	}

	// Types cannot be compared, they do not match.
	switch op {
	case opEq:
		return false, nil
	case opIneq:

		return e.Extract.From.analyze(s)

	case sqlFnDateAdd:
		result.combine(e.DateAdd.Quantity.analyze(s))
		result.combine(e.DateAdd.Timestamp.analyze(s))
		return result

	case sqlFnDateDiff:
		result.combine(e.DateDiff.Timestamp1.analyze(s))
		result.combine(e.DateDiff.Timestamp2.analyze(s))
		return result

	// Handle aggregation function calls
	case aggFnAvg, aggFnMax, aggFnMin, aggFnSum, aggFnCount:

  fun takeEvent(
    eventClass: Class<out CallEvent>? = null,
    elapsedMs: Long = -1L,
  ): CallEvent {
    val result = eventSequence.remove()
    val actualElapsedNs = result.timestampNs - (lastTimestampNs ?: result.timestampNs)
    lastTimestampNs = result.timestampNs

    if (eventClass != null) {
      assertThat(result).isInstanceOf(eventClass)
    }

    if (elapsedMs != -1L) {
      assertThat(

 * Remote snapshot metadata converts artifact on-the-fly to use timestamped snapshot version, and enlist it accordingly.
 *
 * @deprecated since 4.0.0, use {@code maven-api-impl} jar instead
 */
@Deprecated(since = "4.0.0")
class RemoteSnapshotMetadataGenerator implements MetadataGenerator {

    private final Map<Object, RemoteSnapshotMetadata> snapshots;

    private final Date timestamp;

    private final Integer buildNumber;

        String qualifier = formatDate(timestamp, true) + '-' + buildNumber;
        version = version.substring(0, version.length() - SNAPSHOT.length()) + qualifier;
        return addSnapshotVersion(versioning, artifact.getExtension(), timestamp, version, buildNumber);
    }

    private static SnapshotVersion addSnapshotVersion(
            Versioning versioning, String extension, Date timestamp, String version, int buildNumber) {

    eventClass: Class<out ConnectionEvent>? = null,
    elapsedMs: Long = -1L,
  ): ConnectionEvent {
    val result = eventSequence.remove()
    val actualElapsedNs = result.timestampNs - (lastTimestampNs ?: result.timestampNs)
    lastTimestampNs = result.timestampNs

    if (eventClass != null) {
      assertThat(result).isInstanceOf(eventClass)
    }

    if (elapsedMs != -1L) {
      assertThat(
        TimeUnit.NANOSECONDS

    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class RequestHeadersStart(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class RequestHeadersEnd(
    override val timestampNs: Long,
    override val call: Call,
    val headerLength: Long,
  ) : CallEvent() {

        }

        /**
         * Get the notification timestamp
         *
         * @return timestamp in milliseconds
         */
        public long getTimestamp() {
            return timestamp;
        }

        /**
         * Sets the notification timestamp.
         *
         * @param timestamp the timestamp value in FILETIME format (100-nanosecond intervals since January 1, 1601 UTC)

        final Timestamp timestamp = toSqlTimestamp("10/9/7 11:49", Locale.JAPAN);
        assertThat(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(timestamp), is("2010/09/07 11:49:00"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToTimestamp_MediumStyle() throws Exception {
        final Timestamp timestamp = toSqlTimestamp("2010/9/7 11:49:10", Locale.JAPAN);