com.github.mauricio.async.db.postgresql.column.PostgreSQLIntervalEncoderDecoder.scala Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2013 Maurício Linhares
 * Copyright 2013 Dylan Simon
 *
 * Maurício Linhares licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package com.github.mauricio.async.db.postgresql.column

import com.github.mauricio.async.db.column.ColumnEncoderDecoder
import com.github.mauricio.async.db.exceptions.DateEncoderNotAvailableException
import com.github.mauricio.async.db.util.Log
import org.joda.time.{Period, ReadablePeriod, ReadableDuration}
import org.joda.time.format.{ISOPeriodFormat, PeriodFormatterBuilder}

object PostgreSQLIntervalEncoderDecoder extends ColumnEncoderDecoder {

  private val log = Log.getByName(this.getClass.getName)

  /* Postgres accepts all ISO8601 formats. */
  private val formatter = ISOPeriodFormat.standard

  override def encode(value : Any) : String = {
    value match {
      case t : ReadablePeriod => formatter.print(t)
      case t : ReadableDuration => t.toString // defaults to ISO8601
      case _ => throw new DateEncoderNotAvailableException(value)
    }
  }

  /* these should only be used for parsing: */
  private def postgresYMDBuilder(builder : PeriodFormatterBuilder) = builder
    .appendYears  .appendSuffix(" year", " years").appendSeparator(" ")
    .appendMonths .appendSuffix(" mon",  " mons" ).appendSeparator(" ")
    .appendDays   .appendSuffix(" day",  " days" ).appendSeparator(" ")

  private val postgres_verboseParser =
    postgresYMDBuilder(new PeriodFormatterBuilder().appendLiteral("@ "))
    .appendHours  .appendSuffix(" hour", " hours").appendSeparator(" ")
    .appendMinutes.appendSuffix(" min",  " mins" ).appendSeparator(" ")
    .appendSecondsWithOptionalMillis.appendSuffix(" sec", " secs")
    .toFormatter

  private def postgresHMSBuilder(builder : PeriodFormatterBuilder) = builder
    // .printZeroAlways // really all-or-nothing
    .rejectSignedValues(true) // XXX: sign should apply to all
    .appendHours  .appendSuffix(":")
    .appendMinutes.appendSuffix(":")
    .appendSecondsWithOptionalMillis

  private val hmsParser =
    postgresHMSBuilder(new PeriodFormatterBuilder())
    .toFormatter

  private val postgresParser = 
    postgresHMSBuilder(postgresYMDBuilder(new PeriodFormatterBuilder()))
    .toFormatter

  /* These sql_standard parsers don't handle negative signs correctly. */
  private def sqlDTBuilder(builder : PeriodFormatterBuilder) =
    postgresHMSBuilder(builder
    .appendDays.appendSeparator(" "))

  private val sqlDTParser =
    sqlDTBuilder(new PeriodFormatterBuilder())
    .toFormatter

  private val sqlParser =
    sqlDTBuilder(new PeriodFormatterBuilder()
    .printZeroAlways
    .rejectSignedValues(true) // XXX: sign should apply to both
    .appendYears.appendSeparator("-").appendMonths
    .rejectSignedValues(false)
    .printZeroNever
    .appendSeparator(" "))
    .toFormatter

  /* This supports all positive intervals, and intervalstyle of postgres_verbose, and iso_8601 perfectly.
   * If intervalstyle is set to postgres or sql_standard, some negative intervals may be rejected.
   */
  def decode(value : String) : Period = {
    if (value.isEmpty) /* huh? */
      Period.ZERO
    else {
      val format = (
        if (value(0).equals('P')) /* iso_8601 */
          formatter
        else if (value.startsWith("@ "))
          postgres_verboseParser
        else {
          /* try to guess based on what comes after the first number */
          val i = value.indexWhere(!_.isDigit, if ("-+".contains(value(0))) 1 else 0)
          if (i < 0 || ":.".contains(value(i))) /* simple HMS (to support group negation) */
            hmsParser
          else if (value(i).equals('-')) /* sql_standard: Y-M */
            sqlParser
          else if (value(i).equals(' ') && i+1 < value.length && value(i+1).isDigit) /* sql_standard: D H:M:S */
            sqlDTParser
          else
            postgresParser
        }
      )
      if ((format eq hmsParser) && value(0).equals('-'))
        format.parsePeriod(value.substring(1)).negated
      else if (value.endsWith(" ago")) /* only really applies to postgres_verbose, but shouldn't hurt */
        format.parsePeriod(value.stripSuffix(" ago")).negated
      else
        format.parsePeriod(value)
    }
  }
}