Merge lp:~oleksiyk/gearmand/mysql into lp:gearmand/1.0

[Oleksiy Krivoshey]

Support for MySQL based persistent queue using libmysqlclient. Uses prepared statements.

Configuration:

$ gearmand -q MySQL --mysql-host <HOSTNAME> --mysql-db <DATABASE> --mysql-user <USER> --mysql-password <PASSWORD> --mysql-table <TABLE>

$ gearmand --help should show defaults for options above

=== modified file 'configure.ac'
--- configure.ac	2012-01-27 06:44:03 +0000
+++ configure.ac	2012-02-14 10:32:50 +0000
@@ -110,6 +110,9 @@
 SOCKET_SEND_FLAGS
 AX_HAVE_LIBHIREDIS
 
+AX_LIB_MYSQL([5.0])
+AM_CONDITIONAL(HAVE_MYSQL, test "x${HAVE_MYSQL}" = "x1")
+
 # Checks for programs.
 AC_PROG_AWK
 AC_PROG_INSTALL
@@ -244,5 +247,6 @@
 echo "   * Building with libmemcached $ac_enable_libmemcached"
 echo "   * Building with libpq        $ac_cv_libpq"
 echo "   * Building with tokyocabinet $ac_enable_libtokyocabinet"
+echo "   * Building with libmysql     $found_mysql"
 echo ""
 echo "---"
 
=== modified file 'libgearman-server/plugins.cc'
--- libgearman-server/plugins.cc	2012-02-10 02:49:36 +0000
+++ libgearman-server/plugins.cc	2012-02-14 10:32:50 +0000
@@ -78,6 +78,11 @@
     queue::initialize_tokyocabinet();
   }
 
+  if (HAVE_MYSQL)
+  {
+    queue::initialize_mysql();
+  }
+
   gearmand::queue::load_options(all);
 }
 
 
=== modified file 'libgearman-server/plugins/queue.h'
--- libgearman-server/plugins/queue.h	2011-11-29 05:21:54 +0000
+++ libgearman-server/plugins/queue.h	2012-02-14 10:32:50 +0000
@@ -48,3 +48,5 @@
 #include <libgearman-server/plugins/queue/tokyocabinet/queue.h>
 
 #include <libgearman-server/plugins/queue/redis/queue.h>
+
+#include <libgearman-server/plugins/queue/mysql/queue.h>
 
=== modified file 'libgearman-server/plugins/queue/include.am'
--- libgearman-server/plugins/queue/include.am	2011-11-29 05:21:54 +0000
+++ libgearman-server/plugins/queue/include.am	2012-02-14 10:32:50 +0000
@@ -18,3 +18,4 @@
 include libgearman-server/plugins/queue/redis/include.am
 include libgearman-server/plugins/queue/sqlite/include.am
 include libgearman-server/plugins/queue/tokyocabinet/include.am
+include libgearman-server/plugins/queue/mysql/include.am
 
=== added directory 'libgearman-server/plugins/queue/mysql'
=== added file 'libgearman-server/plugins/queue/mysql/include.am'
--- libgearman-server/plugins/queue/mysql/include.am	1970-01-01 00:00:00 +0000
+++ libgearman-server/plugins/queue/mysql/include.am	2012-02-14 10:32:50 +0000
@@ -0,0 +1,19 @@
+# Gearman
+# Copyright (C) 2011 Oleksiy Krivoshey
+# All rights reserved.
+#
+# Use and distribution licensed under the BSD license.  See
+# the COPYING file in the parent directory for full text.
+#
+# All paths should be given relative to the root
+#
+
+noinst_HEADERS+= \
+		 libgearman-server/plugins/queue/mysql/queue.h
+
+libgearman_server_libgearman_server_la_SOURCES+= \
+						 libgearman-server/plugins/queue/mysql/queue.cc
+
+libgearman_server_libgearman_server_la_LIBADD+= $(MYSQL_LDFLAGS)
+
+
 
=== added file 'libgearman-server/plugins/queue/mysql/queue.cc'
--- libgearman-server/plugins/queue/mysql/queue.cc	1970-01-01 00:00:00 +0000
+++ libgearman-server/plugins/queue/mysql/queue.cc	2012-02-14 10:32:50 +0000
@@ -0,0 +1,435 @@
+/* Gearman server and library
+ * Copyright (C) 2011 Oleksiy Krivoshey
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+#include <libgearman-server/common.h>
+#include <libgearman-server/byte.h>
+
+#include <libgearman-server/plugins/queue/mysql/queue.h>
+#include <libgearman-server/plugins/queue/base.h>
+
+#include <mysql/mysql.h>
+#include <mysql/errmsg.h>
+
+/**
+ * Default values.
+ */
+#define GEARMAN_QUEUE_MYSQL_DEFAULT_TABLE "gearman_queue"
+
+namespace gearmand {
+    namespace plugins {
+        namespace queue {
+            class MySQL;
+        }
+    }
+}
+
+static gearmand_error_t _initialize(gearman_server_st *server, gearmand::plugins::queue::MySQL *queue);
+
+namespace gearmand {
+    namespace plugins {
+        namespace queue {
+
+            class MySQL : public gearmand::plugins::Queue {
+            public:
+                MySQL();
+                ~MySQL();
+
+                gearmand_error_t initialize();
+                gearmand_error_t prepareAddStatement();
+                gearmand_error_t prepareDoneStatement();
+
+                MYSQL *con;
+                MYSQL_STMT *add_stmt;
+                MYSQL_STMT *done_stmt;
+                std::string mysql_host;
+                std::string mysql_user;
+                std::string mysql_password;
+                std::string mysql_db;
+                std::string mysql_table;
+            private:
+            };
+
+            MySQL::MySQL() :
+            Queue("MySQL"),
+            con(NULL),
+            add_stmt(NULL) {
+                command_line_options().add_options()
+                        ("mysql-host", boost::program_options::value(&mysql_host)->default_value("localhost"), "MySQL host.")
+                        ("mysql-user", boost::program_options::value(&mysql_user)->default_value(""), "MySQL user.")
+                        ("mysql-password", boost::program_options::value(&mysql_password)->default_value(""), "MySQL user password.")
+                        ("mysql-db", boost::program_options::value(&mysql_db)->default_value(""), "MySQL database.")
+                        ("mysql-table", boost::program_options::value(&mysql_table)->default_value(GEARMAN_QUEUE_MYSQL_DEFAULT_TABLE), "MySQL table name.");
+            }
+
+            MySQL::~MySQL() {
+                if (add_stmt){
+                    mysql_stmt_close(add_stmt);
+                }
+                if (con){
+                    mysql_close(con);
+                }
+            }
+
+            gearmand_error_t MySQL::initialize() {
+                return _initialize(&Gearmand()->server, this);
+            }
+
+            gearmand_error_t MySQL::prepareAddStatement() {
+                char query_buffer[1024];
+
+                if((this->add_stmt = mysql_stmt_init(this->con)) == NULL){
+                    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_init failed: %s", mysql_error(this->con));
+                    return GEARMAN_QUEUE_ERROR;
+                }
+
+                snprintf(query_buffer, sizeof(query_buffer),
+                    "INSERT INTO %s "
+                    "(unique_key, function_name, priority, data, when_to_run) "
+                    "VALUES(?, ?, ?, ?, ?)", this->mysql_table.c_str());
+
+                if (mysql_stmt_prepare(this->add_stmt, query_buffer, strlen(query_buffer))){
+                    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_prepare failed: %s", mysql_error(this->con));
+                    return GEARMAN_QUEUE_ERROR;
+                }
+
+                return GEARMAN_SUCCESS;
+            }
+
+            gearmand_error_t MySQL::prepareDoneStatement() {
+                char query_buffer[1024];
+
+                if((this->done_stmt = mysql_stmt_init(this->con)) == NULL){
+                    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_init failed: %s", mysql_error(this->con));
+                    return GEARMAN_QUEUE_ERROR;
+                }
+
+                snprintf(query_buffer, sizeof(query_buffer),
+                    "DELETE FROM %s "
+                    "WHERE unique_key=? "
+                    "AND function_name=?", this->mysql_table.c_str());
+
+                if (mysql_stmt_prepare(this->done_stmt, query_buffer, strlen(query_buffer))){
+                    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_prepare failed: %s", mysql_error(this->con));
+                    return GEARMAN_QUEUE_ERROR;
+                }
+
+                return GEARMAN_SUCCESS;
+            }
+
+            void initialize_mysql() {
+                static MySQL local_instance;
+            }
+
+        } // namespace queue
+    } // namespace plugin
+} // namespace gearmand
+
+/* Queue callback functions. */
+static gearmand_error_t _mysql_queue_add(gearman_server_st *server, void *context,
+        const char *unique, size_t unique_size,
+        const char *function_name,
+        size_t function_name_size,
+        const void *data, size_t data_size,
+        gearmand_job_priority_t priority,
+        int64_t when);
+
+static gearmand_error_t _mysql_queue_flush(gearman_server_st *server, void *context);
+
+static gearmand_error_t _mysql_queue_done(gearman_server_st *server, void *context,
+        const char *unique,
+        size_t unique_size,
+        const char *function_name,
+        size_t function_name_size);
+
+static gearmand_error_t _mysql_queue_replay(gearman_server_st *server, void *context,
+        gearman_queue_add_fn *add_fn,
+        void *add_context);
+
+
+gearmand_error_t _initialize(gearman_server_st *server,
+        gearmand::plugins::queue::MySQL *queue) {
+
+    MYSQL_RES * result;
+    char query_buffer[1024];
+    my_bool  my_true = true;
+
+    gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM,"Initializing MySQL module");
+
+    gearman_server_set_queue(server, queue, _mysql_queue_add, _mysql_queue_flush, _mysql_queue_done, _mysql_queue_replay);
+
+    queue->con = mysql_init(queue->con);
+
+    mysql_options(queue->con, MYSQL_READ_DEFAULT_GROUP, "gearmand");
+
+    if (!mysql_real_connect(queue->con,
+            queue->mysql_host.c_str(),
+            queue->mysql_user.c_str(),
+            queue->mysql_password.c_str(),
+            queue->mysql_db.c_str(), 0, NULL, 0)) {
+        gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "Failed to connect to database: %s", mysql_error(queue->con));
+
+		return GEARMAN_QUEUE_ERROR;
+    }
+
+    mysql_options(queue->con, MYSQL_OPT_RECONNECT, &my_true);
+
+    if (!(result = mysql_list_tables(queue->con, queue->mysql_table.c_str()))){
+        gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_list_tables failed: %s", mysql_error(queue->con));
+        return GEARMAN_QUEUE_ERROR;
+    }
+
+    if (mysql_num_rows(result) == 0){
+        snprintf(query_buffer, sizeof(query_buffer),
+             "CREATE TABLE %s"
+             "("
+               "unique_key VARCHAR(%d),"
+               "function_name VARCHAR(255),"
+               "priority INT,"
+               "data LONGBLOB,"
+               "when_to_run INT,"
+               "unique key (unique_key, function_name)"
+             ")",
+             queue->mysql_table.c_str(), GEARMAN_UNIQUE_SIZE);
+
+        gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM,"MySQL module: creating table %s", queue->mysql_table.c_str());
+
+        if(mysql_real_query(queue->con, query_buffer, strlen(query_buffer))){
+            gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "MySQL module: create table failed: %s", mysql_error(queue->con));
+            return GEARMAN_QUEUE_ERROR;
+        }
+    }
+
+    mysql_free_result(result);
+
+    if(queue->prepareAddStatement() == GEARMAN_QUEUE_ERROR)
+        return GEARMAN_QUEUE_ERROR;
+
+    if(queue->prepareDoneStatement() == GEARMAN_QUEUE_ERROR)
+        return GEARMAN_QUEUE_ERROR;
+
+    return GEARMAN_SUCCESS;
+}
+
+/*
+ * Static definitions
+ */
+
+
+static gearmand_error_t _mysql_queue_add(gearman_server_st *server, void *context,
+        const char *unique, size_t unique_size,
+        const char *function_name,
+        size_t function_name_size,
+        const void *data, size_t data_size,
+        gearmand_job_priority_t priority,
+        int64_t when) {
+
+    MYSQL_BIND    bind[5];
+    
+    (void) server;
+
+    gearmand::plugins::queue::MySQL *queue = (gearmand::plugins::queue::MySQL *)context;
+
+    gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,"MySQL queue add: %.*s %.*s", (uint32_t) unique_size, (char *) unique,
+        (uint32_t) function_name_size, (char *) function_name);
+
+    bind[0].buffer_type= MYSQL_TYPE_STRING;
+    bind[0].buffer= (char *)unique;
+    bind[0].buffer_length= unique_size;
+    bind[0].is_null= 0;
+    bind[0].length= (unsigned long*)&unique_size;
+
+    bind[1].buffer_type= MYSQL_TYPE_STRING;
+    bind[1].buffer= (char *)function_name;
+    bind[1].buffer_length= function_name_size;
+    bind[1].is_null= 0;
+    bind[1].length= (unsigned long*)&function_name_size;
+
+    bind[2].buffer_type= MYSQL_TYPE_LONG;
+    bind[2].buffer= (char *)&priority;
+    bind[2].is_null= 0;
+    bind[2].length= 0;
+
+    bind[3].buffer_type= MYSQL_TYPE_LONG_BLOB;
+    bind[3].buffer= (char *)data;
+    bind[3].buffer_length= data_size;
+    bind[3].is_null= 0;
+    bind[3].length= (unsigned long*)&data_size;
+
+    bind[4].buffer_type= MYSQL_TYPE_LONG;
+    bind[4].buffer= (char *)&when;
+    bind[4].is_null= 0;
+    bind[4].length= 0;
+
+    while(1){
+        if (mysql_stmt_bind_param(queue->add_stmt, bind)){
+            if ( mysql_stmt_errno(queue->add_stmt) == CR_NO_PREPARE_STMT ){
+                if(queue->prepareAddStatement() == GEARMAN_QUEUE_ERROR){
+                    return GEARMAN_QUEUE_ERROR;
+                }
+                continue;
+            } else {
+                gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_bind_param failed: %s", mysql_error(queue->con));
+                return GEARMAN_QUEUE_ERROR;
+            }
+        }
+
+        if (mysql_stmt_execute(queue->add_stmt)){
+            if ( mysql_stmt_errno(queue->add_stmt) == CR_SERVER_LOST ){
+                mysql_stmt_close(queue->add_stmt);
+                if(queue->prepareAddStatement() != GEARMAN_QUEUE_ERROR){
+                    continue;
+                }
+            }
+            gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_execute failed: %s", mysql_error(queue->con));
+            return GEARMAN_QUEUE_ERROR;
+        }
+        
+        break;
+    }
+
+    return GEARMAN_SUCCESS;
+}
+
+static gearmand_error_t _mysql_queue_flush(gearman_server_st *server,
+        void *context __attribute__((unused))) {
+
+    (void) server;
+    (void) context;
+
+    gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,"MySQL queue flush");
+
+    return GEARMAN_SUCCESS;
+}
+
+static gearmand_error_t _mysql_queue_done(gearman_server_st *server, void *context,
+        const char *unique,
+        size_t unique_size,
+        const char *function_name,
+        size_t function_name_size) {
+
+    MYSQL_BIND    bind[2];
+
+    (void) server;
+
+    gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,"MySQL queue done: %.*s %.*s", (uint32_t) unique_size, (char *) unique,
+        (uint32_t) function_name_size, (char *) function_name);
+
+    gearmand::plugins::queue::MySQL *queue = (gearmand::plugins::queue::MySQL *)context;
+
+    bind[0].buffer_type= MYSQL_TYPE_STRING;
+    bind[0].buffer= (char *)unique;
+    bind[0].buffer_length= unique_size;
+    bind[0].is_null= 0;
+    bind[0].length= (unsigned long*)&unique_size;
+
+    bind[1].buffer_type= MYSQL_TYPE_STRING;
+    bind[1].buffer= (char *)function_name;
+    bind[1].buffer_length= function_name_size;
+    bind[1].is_null= 0;
+    bind[1].length= (unsigned long*)&function_name_size;
+
+    while(1){
+        if (mysql_stmt_bind_param(queue->done_stmt, bind)){
+            if ( mysql_stmt_errno(queue->done_stmt) == CR_NO_PREPARE_STMT ){
+                if(queue->prepareDoneStatement() == GEARMAN_QUEUE_ERROR){
+                    return GEARMAN_QUEUE_ERROR;
+                }
+                continue;
+            } else {
+                gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_bind_param failed: %s", mysql_error(queue->con));
+                return GEARMAN_QUEUE_ERROR;
+            }
+        }
+
+        if (mysql_stmt_execute(queue->done_stmt)){
+            if ( mysql_stmt_errno(queue->done_stmt) == CR_SERVER_LOST ){
+                mysql_stmt_close(queue->done_stmt);
+                if(queue->prepareDoneStatement() != GEARMAN_QUEUE_ERROR){
+                    continue;
+                }
+            }
+            gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_stmt_execute failed: %s", mysql_error(queue->con));
+            return GEARMAN_QUEUE_ERROR;
+        }
+
+        break;
+    }
+
+    return GEARMAN_SUCCESS;
+}
+
+static gearmand_error_t _mysql_queue_replay(gearman_server_st *server, void *context,
+        gearman_queue_add_fn *add_fn,
+        void *add_context) {
+
+    MYSQL_RES * result;
+    MYSQL_ROW row;
+    char query_buffer[1024];
+
+    (void) server;
+
+    gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM,"MySQL queue replay");
+
+    gearmand::plugins::queue::MySQL *queue = (gearmand::plugins::queue::MySQL *)context;
+
+    snprintf(query_buffer, sizeof(query_buffer),
+        "SELECT unique_key, function_name, data, priority, when_to_run FROM %s",
+        queue->mysql_table.c_str());
+
+    if(mysql_real_query(queue->con, query_buffer, strlen(query_buffer))){
+        gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_real_query failed: %s", mysql_error(queue->con));
+        return GEARMAN_QUEUE_ERROR;
+    }
+
+    if(!(result = mysql_store_result(queue->con))){
+        gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "mysql_store_result failed: %s", mysql_error(queue->con));
+        return GEARMAN_QUEUE_ERROR;
+    }
+
+    if(mysql_num_fields(result) < 5){
+        gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "MySQL queue: insufficient row fields in queue table");
+        return GEARMAN_QUEUE_ERROR;
+    }
+
+    gearmand_error_t ret = GEARMAN_SUCCESS;
+
+    while ((row = mysql_fetch_row(result))) {
+        unsigned long *lengths;
+        gearmand_job_priority_t priority = (gearmand_job_priority_t)0;
+        int when = 0;
+
+        lengths = mysql_fetch_lengths(result);
+
+        /* need to make a copy here ... gearman_server_job_free will free it later */
+        size_t data_size= lengths[2];
+        char * data= (char *)malloc(data_size);
+        if (data == NULL){
+            gearmand_perror("malloc failed");
+            return GEARMAN_MEMORY_ALLOCATION_FAILURE;
+        }
+        memcpy(data, row[2], data_size);
+
+        if(lengths[3]) priority = (gearmand_job_priority_t) atoi(row[3]);
+        if(lengths[4]) when = atoi(row[4]);
+
+        ret = (*add_fn)(server, add_context,
+            row[0], (size_t) lengths[0],
+            row[1], (size_t) lengths[1],
+            data, data_size,
+            priority,
+            when);
+
+        if (ret != GEARMAN_SUCCESS) {
+            break;
+        }
+    }
+
+    mysql_free_result(result);
+
+    return ret;
+}
 
=== added file 'libgearman-server/plugins/queue/mysql/queue.h'
--- libgearman-server/plugins/queue/mysql/queue.h	1970-01-01 00:00:00 +0000
+++ libgearman-server/plugins/queue/mysql/queue.h	2012-02-14 10:32:50 +0000
@@ -0,0 +1,48 @@
+/*  
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+
+namespace gearmand {
+namespace plugins {
+namespace queue {
+
+void initialize_mysql();
+
+} // namespace queue
+} // namespace plugin
+} // namespace gearmand
 
=== added file 'm4/ax_lib_mysql.m4'
--- m4/ax_lib_mysql.m4	1970-01-01 00:00:00 +0000
+++ m4/ax_lib_mysql.m4	2012-02-14 10:32:50 +0000
@@ -0,0 +1,147 @@
+# ===========================================================================
+#       http://www.gnu.org/software/autoconf-archive/ax_lib_mysql.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_LIB_MYSQL([MINIMUM-VERSION])
+#
+# DESCRIPTION
+#
+#   This macro provides tests of availability of MySQL client library of
+#   particular version or newer.
+#
+#   AX_LIB_MYSQL macro takes only one argument which is optional. If there
+#   is no required version passed, then macro does not run version test.
+#
+#   The --with-mysql option takes one of three possible values:
+#
+#   no - do not check for MySQL client library
+#
+#   yes - do check for MySQL library in standard locations (mysql_config
+#   should be in the PATH)
+#
+#   path - complete path to mysql_config utility, use this option if
+#   mysql_config can't be found in the PATH
+#
+#   This macro calls:
+#
+#     AC_SUBST(MYSQL_CFLAGS)
+#     AC_SUBST(MYSQL_LDFLAGS)
+#     AC_SUBST(MYSQL_VERSION)
+#
+#   And sets:
+#
+#     HAVE_MYSQL
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Mateusz Loskot <[e-mail]>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 12
+
+AC_DEFUN([AX_LIB_MYSQL],
+[
+    AC_ARG_WITH([mysql],
+        AS_HELP_STRING([--with-mysql=@<:@ARG@:>@],
+            [use MySQL client library @<:@default=yes@:>@, optionally specify path to mysql_config]
+        ),
+        [
+        if test "$withval" = "no"; then
+            want_mysql="no"
+        elif test "$withval" = "yes"; then
+            want_mysql="yes"
+        else
+            want_mysql="yes"
+            MYSQL_CONFIG="$withval"
+        fi
+        ],
+        [want_mysql="yes"]
+    )
+    AC_ARG_VAR([MYSQL_CONFIG], [Full path to mysql_config program])
+
+    MYSQL_CFLAGS=""
+    MYSQL_LDFLAGS=""
+    MYSQL_VERSION=""
+
+    dnl
+    dnl Check MySQL libraries
+    dnl
+
+    if test "$want_mysql" = "yes"; then
+
+        if test -z "$MYSQL_CONFIG" ; then
+            AC_PATH_PROGS([MYSQL_CONFIG], [mysql_config mysql_config5], [no])
+        fi
+
+        if test "$MYSQL_CONFIG" != "no"; then
+            MYSQL_CFLAGS="`$MYSQL_CONFIG --cflags`"
+            MYSQL_LDFLAGS="`$MYSQL_CONFIG --libs`"
+
+            MYSQL_VERSION=`$MYSQL_CONFIG --version`
+
+            found_mysql="yes"
+        else
+            found_mysql="no"
+        fi
+    fi
+
+    dnl
+    dnl Check if required version of MySQL is available
+    dnl
+
+
+    mysql_version_req=ifelse([$1], [], [], [$1])
+
+    if test "$found_mysql" = "yes" -a -n "$mysql_version_req"; then
+
+        AC_MSG_CHECKING([if MySQL version is >= $mysql_version_req])
+
+        dnl Decompose required version string of MySQL
+        dnl and calculate its number representation
+        mysql_version_req_major=`expr $mysql_version_req : '\([[0-9]]*\)'`
+        mysql_version_req_minor=`expr $mysql_version_req : '[[0-9]]*\.\([[0-9]]*\)'`
+        mysql_version_req_micro=`expr $mysql_version_req : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
+        if test "x$mysql_version_req_micro" = "x"; then
+            mysql_version_req_micro="0"
+        fi
+
+        mysql_version_req_number=`expr $mysql_version_req_major \* 1000000 \
+                                   \+ $mysql_version_req_minor \* 1000 \
+                                   \+ $mysql_version_req_micro`
+
+        dnl Decompose version string of installed MySQL
+        dnl and calculate its number representation
+        mysql_version_major=`expr $MYSQL_VERSION : '\([[0-9]]*\)'`
+        mysql_version_minor=`expr $MYSQL_VERSION : '[[0-9]]*\.\([[0-9]]*\)'`
+        mysql_version_micro=`expr $MYSQL_VERSION : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
+        if test "x$mysql_version_micro" = "x"; then
+            mysql_version_micro="0"
+        fi
+
+        mysql_version_number=`expr $mysql_version_major \* 1000000 \
+                                   \+ $mysql_version_minor \* 1000 \
+                                   \+ $mysql_version_micro`
+
+        mysql_version_check=`expr $mysql_version_number \>\= $mysql_version_req_number`
+        if test "$mysql_version_check" = "1"; then
+            AC_MSG_RESULT([yes])
+        else
+            AC_MSG_RESULT([no])
+        fi
+    fi
+
+    if test "$found_mysql" = "yes" ; then
+        AC_DEFINE([HAVE_MYSQL], [1],
+                  [Define to 1 if MySQL libraries are available])
+    fi
+
+    AC_SUBST([MYSQL_VERSION])
+    AC_SUBST([MYSQL_CFLAGS])
+    AC_SUBST([MYSQL_LDFLAGS])
+])