<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
<pkgmetadata>
<maintainer restrict="dev-db/mariadb-galera[libressl]" type="person">
    <email>hasufell@gentoo.org</email>
    <description>Libressl issues. Only assign if it's a direct Libressl issue. Do not directly assign for anything else.</description>
  </maintainer>
<maintainer type="project">
    <email>mysql-bugs@gentoo.org</email>
    <name>MySQL</name>
  </maintainer>
<!-- 
Please note that this list is shared between the following packages:
dev-db/mysql
dev-db/mariadb
-->
<use>
  <flag name="client-libs">Build the libmysqlclient libraries</flag>
  <flag name="embedded">Build embedded server (libmysqld)</flag>
  <flag name="extraengine">Add support for alternative storage engines (Archive, CSV, Blackhole, Federated(X), Partition)</flag>
  <flag name="jemalloc">Use <pkg>dev-libs/jemalloc</pkg> for allocations.</flag>
  <flag name="latin1">Use LATIN1 encoding instead of UTF8</flag>
  <flag name="libressl">Enable SSL connections and crypto functions using <pkg>dev-libs/libressl</pkg></flag>
  <flag name="oqgraph">Add support for the Open Query GRAPH engine</flag>
  <flag name="openssl">Enable SSL connections and crypto functions using <pkg>dev-libs/openssl</pkg></flag>
  <flag name="profiling">Add support for statement profiling (requires USE=community).</flag>
  <flag name="server">Build the server program</flag>
  <flag name="sst-rsync">Add tools needed to support the rsync SST method</flag>
  <flag name="sst-xtrabackup">Add tools needed to support the xtrabackup and xtrabackup-v2 SST methods</flag>
  <flag name="systemtap">Build support for profiling and tracing using <pkg>dev-util/systemtap</pkg></flag>
  <flag name="sphinx">Add suport for the sphinx full-text search engine</flag>
  <flag name="test">Install upstream testsuites for end use.</flag>
  <flag name="tokudb">Add support for TokuDB storage engine</flag>
  <flag name="tools">Build the command line tools (mysql, mysqldump, mysqladmin, etc)</flag>
  <flag name="yassl">Enable SSL connections and crypto functions using the bundled yaSSL</flag>
</use>
</pkgmetadata>
