<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
<pkgmetadata>
<herd>mysql</herd>
  <maintainer restrict="dev-db/mariadb[libressl]">
    <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>
<!-- 
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='cluster'>Add support for NDB clustering (deprecated)</flag>
  <flag name='community'>Enables the community features from upstream.</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='galera'>Enables galera replication</flag>
  <flag name='innodb-lz4'>Enables lz4 compression methods for InnoDB/XtraDB</flag>
  <flag name='innodb-lzo'>Enables lzo compression methods for InnoDB/XtraDB</flag>
  <flag name='innodb-snappy'>Enables snappy compression methods for InnoDB/XtraDB using <pkg>app-arch/snappy</pkg></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='max-idx-128'>Raise the max index per table limit from 64 to 128</flag>
  <flag name='minimal'>Install client programs only, no server</flag>
  <flag name='mroonga'>Add support for the Mroonga engine for interfacing with the Groonga text search</flag>
  <flag name='openssl'>Enable SSL connections and crypto functions using <pkg>dev-libs/openssl</pkg></flag>
  <flag name='oqgraph'>Add support for the Open Query GRAPH engine</flag>
  <flag name='pam'>Enable the optional PAM authentication plugin for the server</flag>
  <flag name='profiling'>Add support for statement profiling (requires USE=community).</flag>
  <flag name='server'>Build the server program</flag>
  <flag name='sphinx'>Add suport for the sphinx full-text search engine</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='tools'>Build the command line tools (mysql, mysqldump, mysqladmin, etc)</flag>
  <flag name='test'>Install upstream testsuites for end use.</flag>
  <flag name='tokudb'>Add support for TokuDB storage engine</flag>
  <flag name='yassl'>Enable SSL connections and crypto functions using the bundled yaSSL</flag>
</use>
</pkgmetadata>
