storage/mozStorageSQLFunctions.cpp
author Bobby Holley <bobbyholley@gmail.com>
Sat, 01 Dec 2018 03:05:56 +0000
changeset 449094 ef8f344dca811b76a6b556d13b3aa7f5452fb5b2
parent 448947 6f3709b3878117466168c40affa7bca0b60cf75b
child 451644 2a2c0b1ebd5c5a8add518189b96456bd3380b134
permissions -rw-r--r--
Bug 1510490 - Measure shader cache memory usage and remove total_gpu_bytes. r=mattwoodrow The latter causes confusion in the memory reports because it gets summed up and thus effectively doubles the reported texture memory usage. I've decided it's best to drop, and so might as well do that while we're already messing around with the memory reports and the associated boilerplate. Depends on D13439 Differential Revision: https://phabricator.services.mozilla.com/D13440

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/ArrayUtils.h"

#include "mozStorageSQLFunctions.h"
#include "nsUnicharUtils.h"
#include <algorithm>

namespace mozilla {
namespace storage {

////////////////////////////////////////////////////////////////////////////////
//// Local Helper Functions

namespace {

/**
 * Performs the LIKE comparison of a string against a pattern.  For more detail
 * see http://www.sqlite.org/lang_expr.html#like.
 *
 * @param aPatternItr
 *        An iterator at the start of the pattern to check for.
 * @param aPatternEnd
 *        An iterator at the end of the pattern to check for.
 * @param aStringItr
 *        An iterator at the start of the string to check for the pattern.
 * @param aStringEnd
 *        An iterator at the end of the string to check for the pattern.
 * @param aEscapeChar
 *        The character to use for escaping symbols in the pattern.
 * @return 1 if the pattern is found, 0 otherwise.
 */
int likeCompare(nsAString::const_iterator aPatternItr,
                nsAString::const_iterator aPatternEnd,
                nsAString::const_iterator aStringItr,
                nsAString::const_iterator aStringEnd, char16_t aEscapeChar) {
  const char16_t MATCH_ALL('%');
  const char16_t MATCH_ONE('_');

  bool lastWasEscape = false;
  while (aPatternItr != aPatternEnd) {
    /**
     * What we do in here is take a look at each character from the input
     * pattern, and do something with it.  There are 4 possibilities:
     * 1) character is an un-escaped match-all character
     * 2) character is an un-escaped match-one character
     * 3) character is an un-escaped escape character
     * 4) character is not any of the above
     */
    if (!lastWasEscape && *aPatternItr == MATCH_ALL) {
      // CASE 1
      /**
       * Now we need to skip any MATCH_ALL or MATCH_ONE characters that follow a
       * MATCH_ALL character.  For each MATCH_ONE character, skip one character
       * in the pattern string.
       */
      while (*aPatternItr == MATCH_ALL || *aPatternItr == MATCH_ONE) {
        if (*aPatternItr == MATCH_ONE) {
          // If we've hit the end of the string we are testing, no match
          if (aStringItr == aStringEnd) return 0;
          aStringItr++;
        }
        aPatternItr++;
      }

      // If we've hit the end of the pattern string, match
      if (aPatternItr == aPatternEnd) return 1;

      while (aStringItr != aStringEnd) {
        if (likeCompare(aPatternItr, aPatternEnd, aStringItr, aStringEnd,
                        aEscapeChar)) {
          // we've hit a match, so indicate this
          return 1;
        }
        aStringItr++;
      }

      // No match
      return 0;
    } else if (!lastWasEscape && *aPatternItr == MATCH_ONE) {
      // CASE 2
      if (aStringItr == aStringEnd) {
        // If we've hit the end of the string we are testing, no match
        return 0;
      }
      aStringItr++;
      lastWasEscape = false;
    } else if (!lastWasEscape && *aPatternItr == aEscapeChar) {
      // CASE 3
      lastWasEscape = true;
    } else {
      // CASE 4
      if (::ToUpperCase(*aStringItr) != ::ToUpperCase(*aPatternItr)) {
        // If we've hit a point where the strings don't match, there is no match
        return 0;
      }
      aStringItr++;
      lastWasEscape = false;
    }

    aPatternItr++;
  }

  return aStringItr == aStringEnd;
}

/**
 * Compute the Levenshtein Edit Distance between two strings.
 *
 * @param aStringS
 *        a string
 * @param aStringT
 *        another string
 * @param _result
 *        an outparam that will receive the edit distance between the arguments
 * @return a Sqlite result code, e.g. SQLITE_OK, SQLITE_NOMEM, etc.
 */
int levenshteinDistance(const nsAString &aStringS, const nsAString &aStringT,
                        int *_result) {
  // Set the result to a non-sensical value in case we encounter an error.
  *_result = -1;

  const uint32_t sLen = aStringS.Length();
  const uint32_t tLen = aStringT.Length();

  if (sLen == 0) {
    *_result = tLen;
    return SQLITE_OK;
  }
  if (tLen == 0) {
    *_result = sLen;
    return SQLITE_OK;
  }

  // Notionally, Levenshtein Distance is computed in a matrix.  If we
  // assume s = "span" and t = "spam", the matrix would look like this:
  //    s -->
  //  t          s   p   a   n
  //  |      0   1   2   3   4
  //  V  s   1   *   *   *   *
  //     p   2   *   *   *   *
  //     a   3   *   *   *   *
  //     m   4   *   *   *   *
  //
  // Note that the row width is sLen + 1 and the column height is tLen + 1,
  // where sLen is the length of the string "s" and tLen is the length of "t".
  // The first row and the first column are initialized as shown, and
  // the algorithm computes the remaining cells row-by-row, and
  // left-to-right within each row.  The computation only requires that
  // we be able to see the current row and the previous one.

  // Allocate memory for two rows.
  AutoTArray<int, nsAutoString::kStorageSize> row1;
  AutoTArray<int, nsAutoString::kStorageSize> row2;

  // Declare the raw pointers that will actually be used to access the memory.
  int *prevRow = row1.AppendElements(sLen + 1);
  int *currRow = row2.AppendElements(sLen + 1);

  // Initialize the first row.
  for (uint32_t i = 0; i <= sLen; i++) prevRow[i] = i;

  const char16_t *s = aStringS.BeginReading();
  const char16_t *t = aStringT.BeginReading();

  // Compute the empty cells in the "matrix" row-by-row, starting with
  // the second row.
  for (uint32_t ti = 1; ti <= tLen; ti++) {
    // Initialize the first cell in this row.
    currRow[0] = ti;

    // Get the character from "t" that corresponds to this row.
    const char16_t tch = t[ti - 1];

    // Compute the remaining cells in this row, left-to-right,
    // starting at the second column (and first character of "s").
    for (uint32_t si = 1; si <= sLen; si++) {
      // Get the character from "s" that corresponds to this column,
      // compare it to the t-character, and compute the "cost".
      const char16_t sch = s[si - 1];
      int cost = (sch == tch) ? 0 : 1;

      // ............ We want to calculate the value of cell "d" from
      // ...ab....... the previously calculated (or initialized) cells
      // ...cd....... "a", "b", and "c", where d = min(a', b', c').
      // ............
      int aPrime = prevRow[si - 1] + cost;
      int bPrime = prevRow[si] + 1;
      int cPrime = currRow[si - 1] + 1;
      currRow[si] = std::min(aPrime, std::min(bPrime, cPrime));
    }

    // Advance to the next row.  The current row becomes the previous
    // row and we recycle the old previous row as the new current row.
    // We don't need to re-initialize the new current row since we will
    // rewrite all of its cells anyway.
    int *oldPrevRow = prevRow;
    prevRow = currRow;
    currRow = oldPrevRow;
  }

  // The final result is the value of the last cell in the last row.
  // Note that that's now in the "previous" row, since we just swapped them.
  *_result = prevRow[sLen];
  return SQLITE_OK;
}

// This struct is used only by registerFunctions below, but ISO C++98 forbids
// instantiating a template dependent on a locally-defined type.  Boo-urns!
struct Functions {
  const char *zName;
  int nArg;
  int enc;
  void *pContext;
  void (*xFunc)(::sqlite3_context *, int, sqlite3_value **);
};

}  // namespace

////////////////////////////////////////////////////////////////////////////////
//// Exposed Functions

int registerFunctions(sqlite3 *aDB) {
  Functions functions[] = {
      {"lower", 1, SQLITE_UTF16, 0, caseFunction},
      {"lower", 1, SQLITE_UTF8, 0, caseFunction},
      {"upper", 1, SQLITE_UTF16, (void *)1, caseFunction},
      {"upper", 1, SQLITE_UTF8, (void *)1, caseFunction},

      {"like", 2, SQLITE_UTF16, 0, likeFunction},
      {"like", 2, SQLITE_UTF8, 0, likeFunction},
      {"like", 3, SQLITE_UTF16, 0, likeFunction},
      {"like", 3, SQLITE_UTF8, 0, likeFunction},

      {"levenshteinDistance", 2, SQLITE_UTF16, 0, levenshteinDistanceFunction},
      {"levenshteinDistance", 2, SQLITE_UTF8, 0, levenshteinDistanceFunction},
  };

  int rv = SQLITE_OK;
  for (size_t i = 0; SQLITE_OK == rv && i < ArrayLength(functions); ++i) {
    struct Functions *p = &functions[i];
    rv = ::sqlite3_create_function(aDB, p->zName, p->nArg, p->enc, p->pContext,
                                   p->xFunc, nullptr, nullptr);
  }

  return rv;
}

////////////////////////////////////////////////////////////////////////////////
//// SQL Functions

void caseFunction(sqlite3_context *aCtx, int aArgc, sqlite3_value **aArgv) {
  NS_ASSERTION(1 == aArgc, "Invalid number of arguments!");

  nsAutoString data(
      static_cast<const char16_t *>(::sqlite3_value_text16(aArgv[0])));
  bool toUpper = ::sqlite3_user_data(aCtx) ? true : false;

  if (toUpper)
    ::ToUpperCase(data);
  else
    ::ToLowerCase(data);

  // Set the result.
  ::sqlite3_result_text16(aCtx, data.get(), -1, SQLITE_TRANSIENT);
}

/**
 * This implements the like() SQL function.  This is used by the LIKE operator.
 * The SQL statement 'A LIKE B' is implemented as 'like(B, A)', and if there is
 * an escape character, say E, it is implemented as 'like(B, A, E)'.
 */
void likeFunction(sqlite3_context *aCtx, int aArgc, sqlite3_value **aArgv) {
  NS_ASSERTION(2 == aArgc || 3 == aArgc, "Invalid number of arguments!");

  if (::sqlite3_value_bytes(aArgv[0]) > SQLITE_MAX_LIKE_PATTERN_LENGTH) {
    ::sqlite3_result_error(aCtx, "LIKE or GLOB pattern too complex",
                           SQLITE_TOOBIG);
    return;
  }

  if (!::sqlite3_value_text16(aArgv[0]) || !::sqlite3_value_text16(aArgv[1]))
    return;

  nsDependentString A(
      static_cast<const char16_t *>(::sqlite3_value_text16(aArgv[1])));
  nsDependentString B(
      static_cast<const char16_t *>(::sqlite3_value_text16(aArgv[0])));
  NS_ASSERTION(!B.IsEmpty(), "LIKE string must not be null!");

  char16_t E = 0;
  if (3 == aArgc)
    E = static_cast<const char16_t *>(::sqlite3_value_text16(aArgv[2]))[0];

  nsAString::const_iterator itrString, endString;
  A.BeginReading(itrString);
  A.EndReading(endString);
  nsAString::const_iterator itrPattern, endPattern;
  B.BeginReading(itrPattern);
  B.EndReading(endPattern);
  ::sqlite3_result_int(
      aCtx, likeCompare(itrPattern, endPattern, itrString, endString, E));
}

void levenshteinDistanceFunction(sqlite3_context *aCtx, int aArgc,
                                 sqlite3_value **aArgv) {
  NS_ASSERTION(2 == aArgc, "Invalid number of arguments!");

  // If either argument is a SQL NULL, then return SQL NULL.
  if (::sqlite3_value_type(aArgv[0]) == SQLITE_NULL ||
      ::sqlite3_value_type(aArgv[1]) == SQLITE_NULL) {
    ::sqlite3_result_null(aCtx);
    return;
  }

  int aLen = ::sqlite3_value_bytes16(aArgv[0]) / sizeof(char16_t);
  const char16_t *a =
      static_cast<const char16_t *>(::sqlite3_value_text16(aArgv[0]));

  int bLen = ::sqlite3_value_bytes16(aArgv[1]) / sizeof(char16_t);
  const char16_t *b =
      static_cast<const char16_t *>(::sqlite3_value_text16(aArgv[1]));

  // Compute the Levenshtein Distance, and return the result (or error).
  int distance = -1;
  const nsDependentString A(a, aLen);
  const nsDependentString B(b, bLen);
  int status = levenshteinDistance(A, B, &distance);
  if (status == SQLITE_OK) {
    ::sqlite3_result_int(aCtx, distance);
  } else if (status == SQLITE_NOMEM) {
    ::sqlite3_result_error_nomem(aCtx);
  } else {
    ::sqlite3_result_error(aCtx, "User function returned error code", -1);
  }
}

}  // namespace storage
}  // namespace mozilla