Merge work:/home/bk/mysql into donna.mysql.fi:/home/my/bk/mysql

Created by Laurent Bossavit of NetDIVE.

@strong{NOTE:} Doesn't work with Access2!

@item @uref{http://www.mysql.com/Downloads/Contrib/msql2mysqlWrapper-1.0.tgz, /msql2mysqlWrapper 1.0}

@item @uref{http://www.mysql.com/Downloads/Contrib/mdb2sql.bas, mdb2sql.bas}

Converter from Access97 to @strong{MySQL} by Moshe Gurvich.

@item @uref{http://www.mysql.com/Downloads/Contrib/msql2mysqlWrapper-1.0.tgz, msql2mysqlWrapper 1.0}

A C wrapper from @code{mSQL} to @strong{MySQL}. By @email{alfred@@sb.net}

@item @uref{http://www.mysql.com/Downloads/Contrib/sqlconv.pl, sqlconv.pl}

A simple script that can be used to copy fields from one @strong{MySQL} table to

another in bulk. Basically, you can run @code{mysqldump} and pipe it to

A simple script that can be used to copy fields from one @strong{MySQL} table

to another in bulk. Basically, you can run @code{mysqldump} and pipe it to

the @code{sqlconv.pl} script. The script will parse through the

@code{mysqldump} output and will rearrange the fields so they can be

inserted into a new table. An example is when you want to create a new

table for a different site you are working on, but the table is just a

bit different (that is - fields in different order, etc.).

By Steve Shreeve.

@item @uref{http://www.mysql.com/Downloads/Contrib/oracledump, oracledump}

Perl program to convert Oracle databases to @strong{MySQL}. By Johan Andersson.

@end itemize

@appendixsec Using MySQL with Other Products

	$(CC) $(CFLAGS) $?

vsnprintf@o@: $(srcdir)/clib/vsnprintf.c

	$(CC) $(CFLAGS) $?

# Don't update the files from bitkeeper

%::SCCS/s.%

}

#ifndef DBUG_OFF

#if !defined(DBUG_OFF) && !defined(EXTRA_DEBUG)

#define DBUG_OFF				/* This should work */

#endif

/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB

/* Copyright (C) 1991, 1992, 1996, 1997 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   Written by Douglas C. Schmidt (schmidt@ics.uci.edu).

   This library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Library General Public

   License as published by the Free Software Foundation; either

   version 2 of the License, or (at your option) any later version.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Library General Public License as

   published by the Free Software Foundation; either version 2 of the

   License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public

   License along with this library; if not, write to the Free

   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

   MA 02111-1307, USA */

/* Plug-compatible replacement for UNIX qsort.

   Copyright (C) 1989 Free Software Foundation, Inc.

   Written by Douglas C. Schmidt (schmidt@ics.uci.edu)

   Optimized and modyfied for mysys by monty.

This file is part of GNU CC.

GNU QSORT is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 1, or (at your option)

any later version.

GNU QSORT is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with GNU QSORT; see the file COPYING.  If not, write to

the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */

   License along with the GNU C Library; see the file COPYING.LIB.  If not,

   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.	*/

/*

    Modifications by monty:

  - Uses mysys include files

  - Small fixes to make the it a bit faster

  - Can be compiled with a cmp function that takes one extra argument.

*/

#include "mysys_priv.h"

#endif

/* Byte-wise swap two items of size SIZE. */

#define SWAP(A,B,SIZE) do {int sz=(int)(SIZE); char *a = (A); char *b = (B); \

    do { char _temp = *a;*a++ = *b;*b++ = _temp;} while (--sz);} while (0)

/* Copy SIZE bytes from item B to item A. */

#define COPY(A,B,SIZE) {int sz = (int) (SIZE); do { *(A)++ = *(B)++; } while (--sz); }

/* This should be replaced by a standard ANSI macro. */

#define BYTES_PER_WORD 8

/* The next 4 #defines implement a very fast in-line stack abstraction. */

#define STACK_SIZE (BYTES_PER_WORD * sizeof (long))

#define PUSH(LOW,HIGH) do {top->lo = LOW;top++->hi = HIGH;} while (0)

#define POP(LOW,HIGH)  do {LOW = (--top)->lo;HIGH = top->hi;} while (0)

#define STACK_NOT_EMPTY (stack < top)

#define SWAP(a, b, size)						      \

  do									      \

    {									      \

      register size_t __size = (size);					      \

      register char *__a = (a), *__b = (b);				      \

      do								      \

	{								      \

	  char __tmp = *__a;						      \

	  *__a++ = *__b;						      \

	  *__b++ = __tmp;						      \

	} while (--__size > 0);						      \

    } while (0)

/* Discontinue quicksort algorithm when partition gets below this size.

   This particular magic number was chosen to work best on a Sparc SLC. */

#define MAX_THRESH 12

   This particular magic number was chosen to work best on a Sun 4/260. */

#define MAX_THRESH 8

/* Stack node declarations used to store unfulfilled partition obligations. */

typedef struct

    char *hi;

  } stack_node;

/* The next 4 #defines implement a very fast in-line stack abstraction. */

#define STACK_SIZE	(8 * sizeof(unsigned long int))

#define PUSH(LOW,HIGH) do {top->lo = LOW;top++->hi = HIGH;} while (0)

#define POP(LOW,HIGH)  do {LOW = (--top)->lo;HIGH = top->hi;} while (0)

#define STACK_NOT_EMPTY (stack < top)

/* Order size using quicksort.	This implementation incorporates

   four optimizations discussed in Sedgewick:

   3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving

      insertion sort to order the MAX_THRESH items within each partition.

      This is a big win, since insertion sort is faster for small, mostly

      sorted array segements.

      sorted array segments.

   4. The larger of the two sub-partitions is always pushed onto the

      stack first, with the algorithm then concentrating on the

  /* Allocating SIZE bytes for a pivot buffer facilitates a better

     algorithm below since we can do comparisons directly on the pivot.

     */

  int	max_thresh   = (int) (MAX_THRESH * size);

  size_t max_thresh   = (size_t) (MAX_THRESH * size);

  if (total_elems <= 1)

    SORT_RETURN;		/* Crashes on MSDOS if continues */

  if (total_elems > MAX_THRESH)

  {

    char       *lo = base_ptr;

    char       *hi = lo + size * (total_elems - 1);

    char       *hi = &lo[size * (total_elems - 1)];

    stack_node stack[STACK_SIZE]; /* Largest size needed for 32-bit int!!! */

    stack_node *top = stack + 1;

    char *pivot_buffer = (char *) my_alloca ((int) size);

    char *pivot = (char *) my_alloca ((int) size);

#ifdef HAVE_purify

    stack[0].lo=stack[0].hi=0;

#endif

    while (STACK_NOT_EMPTY)

    {

      char *left_ptr;

      char *right_ptr;

      {

	char *pivot = pivot_buffer;

    do

    {

      char *left_ptr,*right_ptr;

      /* Select median value from among LO, MID, and HI. Rearrange

	 LO and HI so the three values are sorted. This lowers the

	 probability of picking a pathological pivot value and

	 skips a comparison for both the LEFT_PTR and RIGHT_PTR. */

	  char *mid = lo + size * (((uint) (hi - lo) / (uint) size) >> 1);

      char *mid = lo + size * (((ulong) (hi - lo) / (ulong) size) >> 1);

      if (CMP(hi,lo) < 0)

	SWAP (hi, lo, size);

	SWAP (mid, lo, size);

      else if (CMP (hi, mid) < 0)

	SWAP (mid, hi, size);

	  COPY (pivot, mid, size);

	  pivot = pivot_buffer;

	}

      memcpy (pivot, mid, size);

      left_ptr	= lo + size;

      right_ptr = hi - size;

	  right_ptr -= size;

	  break;

	}

	else

	  break;				/* left_ptr > right_ptr */

      }

      while (left_ptr <= right_ptr);

      }

      /* Set up pointers for next iteration.  First determine whether

	 left and right partitions are below the threshold size. If so,

	 ignore one or both.  Otherwise, push the larger partition's

	 bounds on the stack and continue sorting the smaller one. */

      if ((right_ptr - lo) <= max_thresh)

      if ((size_t) (right_ptr - lo) <= max_thresh)

      {

	if ((hi - left_ptr) <= max_thresh)	/* Ignore both small parts. */

	  POP (lo, hi);

	else					/* Ignore small left part. */

	  lo = left_ptr;

	if ((size_t) (hi - left_ptr) <= max_thresh)

	  POP (lo, hi);			/* Ignore both small partitions. */

	else

	  lo = left_ptr;		/* Ignore small left part. */

      }

      else if ((hi - left_ptr) <= max_thresh)	/* Ignore small right part. */

	hi = right_ptr;

      else if ((right_ptr - lo) > (hi - left_ptr)) /* Push larger left part */

      else if ((size_t) (hi - left_ptr) <= max_thresh)

	hi = right_ptr;			/* Ignore small right partition. */

      else if ((right_ptr - lo) > (hi - left_ptr))

      {

	PUSH (lo, right_ptr);

	PUSH (lo, right_ptr);		/* Push larger left part */

	lo = left_ptr;

      }

      else					/* Push larger right part */

      else

      {

	PUSH (left_ptr, hi);

	PUSH (left_ptr, hi);		/* Push larger right part */

	hi = right_ptr;

      }

    }

    my_afree(pivot_buffer);

    } while (STACK_NOT_EMPTY);

    my_afree(pivot);

  }

  /* Once the BASE_PTR array is partially sorted by quicksort the rest

  {

    char *end_ptr = (char*) base_ptr + size * (total_elems - 1);

    char *run_ptr;

    char *tmp_ptr = (char*) base_ptr;

    char *thresh  = min (end_ptr, (char*) base_ptr + max_thresh);

    register char *run_ptr;

    /* Find smallest element in first threshold and place it at the

       array's beginning.  This is the smallest array element,

    if (tmp_ptr != (char*) base_ptr)

      SWAP (tmp_ptr, (char*) base_ptr, size);

    /* Insertion sort, running from left-hand-side up to `right-hand-side.'

       Pretty much straight out of the original GNU qsort routine. */

    /* Insertion sort, running from left-hand-side up to right-hand-side.  */

    for (run_ptr = (char*) base_ptr + size;

	 (tmp_ptr = run_ptr += size) <= end_ptr; )

	 (run_ptr += size) <= end_ptr; )

    {

      while (CMP (run_ptr, tmp_ptr -= size) < 0) ;

      if ((tmp_ptr += size) != run_ptr)

      if (CMP (run_ptr, (tmp_ptr = run_ptr-size)) < 0)

      {

	char *trav;

	while (CMP (run_ptr, tmp_ptr -= size) < 0) ;

	tmp_ptr += size;

	/* Shift down all smaller elements, put found element in 'run_ptr' */

	for (trav = run_ptr + size; --trav >= run_ptr;)

	{

	  char c = *trav;

	  *hi = c;

	}

      }

    }

  }

  SORT_RETURN;

			ha_gemini.h opt_range.h opt_ft.h \

			sql_select.h structs.h table.h sql_udf.h hash_filo.h\

			lex.h lex_symbol.h sql_acl.h sql_crypt.h md5.h \

                        log_event.h mini_client.h sql_repl.h slave.h

                        log_event.h mini_client.h sql_repl.h slave.h \

			stacktrace.h

mysqld_SOURCES =	sql_lex.cc \

			item.cc item_sum.cc item_buff.cc item_func.cc \

			item_cmpfunc.cc item_strfunc.cc item_timefunc.cc \

			sql_base.cc table.cc sql_select.cc sql_insert.cc \

			sql_update.cc sql_delete.cc \

			procedure.cc item_uniq.cc sql_test.cc \

			log.cc init.cc derror.cc sql_acl.cc unireg.cc \

			log.cc log_event.cc init.cc derror.cc sql_acl.cc \

			unireg.cc \

			time.cc opt_range.cc opt_sum.cc opt_ft.cc \

		   	records.cc filesort.cc handler.cc \

		        ha_isam.cc ha_isammrg.cc ha_heap.cc \

			ha_myisam.cc ha_myisammrg.cc ha_berkeley.cc \

	                ha_innobase.cc ha_gemini.cc \

		        ha_heap.cc ha_myisam.cc ha_myisammrg.cc \

	                ha_berkeley.cc ha_innobase.cc ha_gemini.cc \

			ha_isam.cc ha_isammrg.cc \

			sql_db.cc sql_table.cc sql_rename.cc sql_crypt.cc \

			sql_load.cc mf_iocache.cc field_conv.cc sql_show.cc \

			sql_udf.cc sql_analyse.cc sql_analyse.h sql_cache.cc \

			slave.cc sql_repl.cc \

			md5.c log_event.cc mini_client.cc mini_client_errors.c

			mini_client.cc mini_client_errors.c \

			md5.c stacktrace.c

gen_lex_hash_SOURCES =	gen_lex_hash.cc

gen_lex_hash_LDADD =	$(LDADD) $(CXXLDFLAGS)

mysqlbinlog_SOURCES =   mysqlbinlog.cc mini_client.cc net_serv.cc \