added source folders
This commit is contained in:
purpleyouko committed
1 parent
f23521f720
commit
cfdc19df45
145 files changed
+54574
No files matched your search
+52
@@ -0,0 +1,52 @@
|
||||
/* Copyright (C) 2000 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
/*
|
||||
Data structures for mysys/my_alloc.c (root memory allocator)
|
||||
*/
|
||||
|
||||
#ifndef _my_alloc_h
|
||||
#define _my_alloc_h
|
||||
|
||||
#define ALLOC_MAX_BLOCK_TO_DROP 4096
|
||||
#define ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP 10
|
||||
|
||||
typedef struct st_used_mem
|
||||
{ /* struct for once_alloc (block) */
|
||||
struct st_used_mem *next; /* Next block in use */
|
||||
unsigned int left; /* memory left in block */
|
||||
unsigned int size; /* size of block */
|
||||
} USED_MEM;
|
||||
|
||||
|
||||
typedef struct st_mem_root
|
||||
{
|
||||
USED_MEM *free; /* blocks with free memory in it */
|
||||
USED_MEM *used; /* blocks almost without free memory */
|
||||
USED_MEM *pre_alloc; /* preallocated block */
|
||||
/* if block have less memory it will be put in 'used' list */
|
||||
unsigned int min_malloc;
|
||||
unsigned int block_size; /* initial block size */
|
||||
unsigned int block_num; /* allocated blocks counter */
|
||||
/*
|
||||
first free block in queue test counter (if it exceed
|
||||
MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
|
||||
*/
|
||||
unsigned int first_block_usage;
|
||||
|
||||
void (*error_handler)(void);
|
||||
} MEM_ROOT;
|
||||
#endif
|
||||
+101
@@ -0,0 +1,101 @@
|
||||
/* Copyright (C) 2000 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#ifndef _dbug_h
|
||||
#define _dbug_h
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#if !defined(DBUG_OFF) && !defined(_lint)
|
||||
extern int _db_on_,_no_db_;
|
||||
extern FILE *_db_fp_;
|
||||
extern char *_db_process_;
|
||||
extern int _db_keyword_(const char *keyword);
|
||||
extern int _db_strict_keyword_(const char *keyword);
|
||||
extern void _db_setjmp_(void);
|
||||
extern void _db_longjmp_(void);
|
||||
extern void _db_push_(const char *control);
|
||||
extern void _db_pop_(void);
|
||||
extern void _db_enter_(const char *_func_,const char *_file_,uint _line_,
|
||||
const char **_sfunc_,const char **_sfile_,
|
||||
uint *_slevel_, char ***);
|
||||
extern void _db_return_(uint _line_,const char **_sfunc_,const char **_sfile_,
|
||||
uint *_slevel_);
|
||||
extern void _db_pargs_(uint _line_,const char *keyword);
|
||||
extern void _db_doprnt_ _VARARGS((const char *format,...));
|
||||
extern void _db_dump_(uint _line_,const char *keyword,const char *memory,
|
||||
uint length);
|
||||
extern void _db_output_(uint flag);
|
||||
extern void _db_lock_file(void);
|
||||
extern void _db_unlock_file(void);
|
||||
|
||||
#define DBUG_ENTER(a) const char *_db_func_, *_db_file_; uint _db_level_; \
|
||||
char **_db_framep_; \
|
||||
_db_enter_ (a,__FILE__,__LINE__,&_db_func_,&_db_file_,&_db_level_, \
|
||||
&_db_framep_)
|
||||
#define DBUG_LEAVE \
|
||||
(_db_return_ (__LINE__, &_db_func_, &_db_file_, &_db_level_))
|
||||
#define DBUG_RETURN(a1) {DBUG_LEAVE; return(a1);}
|
||||
#define DBUG_VOID_RETURN {DBUG_LEAVE; return;}
|
||||
#define DBUG_EXECUTE(keyword,a1) \
|
||||
{if (_db_on_) {if (_db_keyword_ (keyword)) { a1 }}}
|
||||
#define DBUG_PRINT(keyword,arglist) \
|
||||
{if (_db_on_) {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;}}
|
||||
#define DBUG_PUSH(a1) _db_push_ (a1)
|
||||
#define DBUG_POP() _db_pop_ ()
|
||||
#define DBUG_PROCESS(a1) (_db_process_ = a1)
|
||||
#define DBUG_FILE (_db_fp_)
|
||||
#define DBUG_SETJMP(a1) (_db_setjmp_ (), setjmp (a1))
|
||||
#define DBUG_LONGJMP(a1,a2) (_db_longjmp_ (), longjmp (a1, a2))
|
||||
#define DBUG_DUMP(keyword,a1,a2)\
|
||||
{if (_db_on_) {_db_dump_(__LINE__,keyword,a1,a2);}}
|
||||
#define DBUG_IN_USE (_db_fp_ && _db_fp_ != stderr)
|
||||
#define DEBUGGER_OFF _no_db_=1;_db_on_=0;
|
||||
#define DEBUGGER_ON _no_db_=0
|
||||
#define DBUG_LOCK_FILE { _db_lock_file(); }
|
||||
#define DBUG_UNLOCK_FILE { _db_unlock_file(); }
|
||||
#define DBUG_OUTPUT(A) { _db_output_(A); }
|
||||
#define DBUG_ASSERT(A) assert(A)
|
||||
#define DBUG_EXECUTE_IF(keyword,a1) \
|
||||
{if (_db_on_) {if (_db_strict_keyword_ (keyword)) { a1 }}}
|
||||
#else /* No debugger */
|
||||
|
||||
#define DBUG_ENTER(a1)
|
||||
#define DBUG_RETURN(a1) return(a1)
|
||||
#define DBUG_VOID_RETURN return
|
||||
#define DBUG_EXECUTE(keyword,a1) {}
|
||||
#define DBUG_EXECUTE_IF(keyword,a1) {}
|
||||
#define DBUG_PRINT(keyword,arglist) {}
|
||||
#define DBUG_PUSH(a1) {}
|
||||
#define DBUG_POP() {}
|
||||
#define DBUG_PROCESS(a1) {}
|
||||
#define DBUG_FILE (stderr)
|
||||
#define DBUG_SETJMP setjmp
|
||||
#define DBUG_LONGJMP longjmp
|
||||
#define DBUG_DUMP(keyword,a1,a2) {}
|
||||
#define DBUG_IN_USE 0
|
||||
#define DEBUGGER_OFF
|
||||
#define DEBUGGER_ON
|
||||
#define DBUG_LOCK_FILE
|
||||
#define DBUG_UNLOCK_FILE
|
||||
#define DBUG_OUTPUT(A)
|
||||
#define DBUG_ASSERT(A) {}
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
+77
@@ -0,0 +1,77 @@
|
||||
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#ifndef _my_getopt_h
|
||||
#define _my_getopt_h
|
||||
|
||||
C_MODE_START
|
||||
|
||||
#define GET_NO_ARG 1
|
||||
#define GET_BOOL 2
|
||||
#define GET_INT 3
|
||||
#define GET_UINT 4
|
||||
#define GET_LONG 5
|
||||
#define GET_ULONG 6
|
||||
#define GET_LL 7
|
||||
#define GET_ULL 8
|
||||
#define GET_STR 9
|
||||
#define GET_STR_ALLOC 10
|
||||
#define GET_DISABLED 11
|
||||
|
||||
#define GET_ASK_ADDR 128
|
||||
#define GET_TYPE_MASK 127
|
||||
|
||||
enum get_opt_arg_type { NO_ARG, OPT_ARG, REQUIRED_ARG };
|
||||
|
||||
struct my_option
|
||||
{
|
||||
const char *name; /* Name of the option */
|
||||
int id; /* unique id or short option */
|
||||
const char *comment; /* option comment, for autom. --help */
|
||||
gptr *value; /* The variable value */
|
||||
gptr *u_max_value; /* The user def. max variable value */
|
||||
const char **str_values; /* Pointer to possible values */
|
||||
ulong var_type;
|
||||
enum get_opt_arg_type arg_type;
|
||||
longlong def_value; /* Default value */
|
||||
longlong min_value; /* Min allowed value */
|
||||
longlong max_value; /* Max allowed value */
|
||||
longlong sub_size; /* Subtract this from given value */
|
||||
long block_size; /* Value should be a mult. of this */
|
||||
int app_type; /* To be used by an application */
|
||||
};
|
||||
|
||||
typedef my_bool (* my_get_one_option) (int, const struct my_option *, char * );
|
||||
typedef void (* my_error_reporter) (enum loglevel level, const char *format, ... );
|
||||
|
||||
extern char *disabled_my_option;
|
||||
extern my_bool my_getopt_print_errors;
|
||||
extern my_error_reporter my_getopt_error_reporter;
|
||||
|
||||
extern int handle_options (int *argc, char ***argv,
|
||||
const struct my_option *longopts, my_get_one_option);
|
||||
extern void my_print_help(const struct my_option *options);
|
||||
extern void my_print_variables(const struct my_option *options);
|
||||
extern void my_getopt_register_get_addr(gptr* (*func_addr)(const char *, uint,
|
||||
const struct my_option *));
|
||||
|
||||
ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp);
|
||||
my_bool getopt_compare_strings(const char *s, const char *t, uint length);
|
||||
|
||||
C_MODE_END
|
||||
|
||||
#endif /* _my_getopt_h */
|
||||
|
||||
+1276
File diff suppressed because it is too large.
Load diff
+46
@@ -0,0 +1,46 @@
|
||||
/* Copyright (C) 2000 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#ifndef _list_h_
|
||||
#define _list_h_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct st_list {
|
||||
struct st_list *prev,*next;
|
||||
void *data;
|
||||
} LIST;
|
||||
|
||||
typedef int (*list_walk_action)(void *,void *);
|
||||
|
||||
extern LIST *list_add(LIST *root,LIST *element);
|
||||
extern LIST *list_delete(LIST *root,LIST *element);
|
||||
extern LIST *list_cons(void *data,LIST *root);
|
||||
extern LIST *list_reverse(LIST *root);
|
||||
extern void list_free(LIST *root,unsigned int free_data);
|
||||
extern unsigned int list_length(LIST *);
|
||||
extern int list_walk(LIST *,list_walk_action action,gptr argument);
|
||||
|
||||
#define list_rest(a) ((a)->next)
|
||||
#define list_push(a,b) (a)=list_cons((b),(a))
|
||||
#define list_pop(A) {LIST *old=(A); (A)=list_delete(old,old) ; my_free((gptr) old,MYF(MY_FAE)); }
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
Vendored
+903
@@ -0,0 +1,903 @@
|
||||
/* Copyright (C) 2000-2003 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#ifndef _my_sys_h
|
||||
#define _my_sys_h
|
||||
C_MODE_START
|
||||
|
||||
#ifdef HAVE_AIOWAIT
|
||||
#include <sys/asynch.h> /* Used by record-cache */
|
||||
typedef struct my_aio_result {
|
||||
aio_result_t result;
|
||||
int pending;
|
||||
} my_aio_result;
|
||||
#endif
|
||||
|
||||
#ifndef THREAD
|
||||
extern int NEAR my_errno; /* Last error in mysys */
|
||||
#else
|
||||
#include <my_pthread.h>
|
||||
#endif
|
||||
|
||||
#ifndef _m_ctype_h
|
||||
#include <m_ctype.h> /* for CHARSET_INFO */
|
||||
#endif
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <typelib.h>
|
||||
|
||||
#define MYSYS_PROGRAM_USES_CURSES() { error_handler_hook = my_message_curses; mysys_uses_curses=1; }
|
||||
#define MYSYS_PROGRAM_DONT_USE_CURSES() { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
|
||||
#define MY_INIT(name); { my_progname= name; my_init(); }
|
||||
|
||||
#define ERRMSGSIZE (SC_MAXWIDTH) /* Max length of a error message */
|
||||
#define NRERRBUFFS (2) /* Buffers for parameters */
|
||||
#define MY_FILE_ERROR ((uint) ~0)
|
||||
|
||||
/* General bitmaps for my_func's */
|
||||
#define MY_FFNF 1 /* Fatal if file not found */
|
||||
#define MY_FNABP 2 /* Fatal if not all bytes read/writen */
|
||||
#define MY_NABP 4 /* Error if not all bytes read/writen */
|
||||
#define MY_FAE 8 /* Fatal if any error */
|
||||
#define MY_WME 16 /* Write message on error */
|
||||
#define MY_WAIT_IF_FULL 32 /* Wait and try again if disk full error */
|
||||
#define MY_IGNORE_BADFD 32 /* my_sync: ignore 'bad descriptor' errors */
|
||||
#define MY_RAID 64 /* Support for RAID */
|
||||
#define MY_FULL_IO 512 /* For my_read - loop intil I/O is complete */
|
||||
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
|
||||
#define MY_LINK_WARNING 32 /* my_redel() gives warning if links */
|
||||
#define MY_COPYTIME 64 /* my_redel() copys time */
|
||||
#define MY_DELETE_OLD 256 /* my_create_with_symlink() */
|
||||
#define MY_RESOLVE_LINK 128 /* my_realpath(); Only resolve links */
|
||||
#define MY_HOLD_ORIGINAL_MODES 128 /* my_copy() holds to file modes */
|
||||
#define MY_REDEL_MAKE_BACKUP 256
|
||||
#define MY_SEEK_NOT_DONE 32 /* my_lock may have to do a seek */
|
||||
#define MY_DONT_WAIT 64 /* my_lock() don't wait if can't lock */
|
||||
#define MY_ZEROFILL 32 /* my_malloc(), fill array with zero */
|
||||
#define MY_ALLOW_ZERO_PTR 64 /* my_realloc() ; zero ptr -> malloc */
|
||||
#define MY_FREE_ON_ERROR 128 /* my_realloc() ; Free old ptr on error */
|
||||
#define MY_HOLD_ON_ERROR 256 /* my_realloc() ; Return old ptr on error */
|
||||
#define MY_THREADSAFE 128 /* pread/pwrite: Don't allow interrupts */
|
||||
#define MY_DONT_OVERWRITE_FILE 1024 /* my_copy: Don't overwrite file */
|
||||
|
||||
#define MY_CHECK_ERROR 1 /* Params to my_end; Check open-close */
|
||||
#define MY_GIVE_INFO 2 /* Give time info about process*/
|
||||
|
||||
#define ME_HIGHBYTE 8 /* Shift for colours */
|
||||
#define ME_NOCUR 1 /* Don't use curses message */
|
||||
#define ME_OLDWIN 2 /* Use old window */
|
||||
#define ME_BELL 4 /* Ring bell then printing message */
|
||||
#define ME_HOLDTANG 8 /* Don't delete last keys */
|
||||
#define ME_WAITTOT 16 /* Wait for errtime secs of for a action */
|
||||
#define ME_WAITTANG 32 /* Wait for a user action */
|
||||
#define ME_NOREFRESH 64 /* Dont refresh screen */
|
||||
#define ME_NOINPUT 128 /* Dont use the input libary */
|
||||
#define ME_COLOUR1 ((1 << ME_HIGHBYTE)) /* Possibly error-colours */
|
||||
#define ME_COLOUR2 ((2 << ME_HIGHBYTE))
|
||||
#define ME_COLOUR3 ((3 << ME_HIGHBYTE))
|
||||
|
||||
/* Bits in last argument to fn_format */
|
||||
#define MY_REPLACE_DIR 1 /* replace dir in name with 'dir' */
|
||||
#define MY_REPLACE_EXT 2 /* replace extension with 'ext' */
|
||||
#define MY_UNPACK_FILENAME 4 /* Unpack name (~ -> home) */
|
||||
#define MY_PACK_FILENAME 8 /* Pack name (home -> ~) */
|
||||
#define MY_RESOLVE_SYMLINKS 16 /* Resolve all symbolic links */
|
||||
#define MY_RETURN_REAL_PATH 32 /* return full path for file */
|
||||
#define MY_SAFE_PATH 64 /* Return NULL if too long path */
|
||||
#define MY_RELATIVE_PATH 128 /* name is relative to 'dir' */
|
||||
|
||||
/* My seek flags */
|
||||
#define MY_SEEK_SET 0
|
||||
#define MY_SEEK_CUR 1
|
||||
#define MY_SEEK_END 2
|
||||
|
||||
/* Some constants */
|
||||
#define MY_WAIT_FOR_USER_TO_FIX_PANIC 60 /* in seconds */
|
||||
#define MY_WAIT_GIVE_USER_A_MESSAGE 10 /* Every 10 times of prev */
|
||||
#define MIN_COMPRESS_LENGTH 50 /* Don't compress small bl. */
|
||||
#define DFLT_INIT_HITS 3
|
||||
|
||||
/* root_alloc flags */
|
||||
#define MY_KEEP_PREALLOC 1
|
||||
#define MY_MARK_BLOCKS_FREE 2 /* move used to free list and reuse them */
|
||||
|
||||
/* Internal error numbers (for assembler functions) */
|
||||
#define MY_ERRNO_EDOM 33
|
||||
#define MY_ERRNO_ERANGE 34
|
||||
|
||||
/* Bits for get_date timeflag */
|
||||
#define GETDATE_DATE_TIME 1
|
||||
#define GETDATE_SHORT_DATE 2
|
||||
#define GETDATE_HHMMSSTIME 4
|
||||
#define GETDATE_GMT 8
|
||||
#define GETDATE_FIXEDLENGTH 16
|
||||
|
||||
/* defines when allocating data */
|
||||
#ifdef SAFEMALLOC
|
||||
#define my_malloc(SZ,FLAG) _mymalloc((SZ), __FILE__, __LINE__, FLAG )
|
||||
#define my_malloc_ci(SZ,FLAG) _mymalloc((SZ), sFile, uLine, FLAG )
|
||||
#define my_realloc(PTR,SZ,FLAG) _myrealloc((PTR), (SZ), __FILE__, __LINE__, FLAG )
|
||||
#define my_checkmalloc() _sanity( __FILE__, __LINE__ )
|
||||
#define my_free(PTR,FLAG) _myfree((PTR), __FILE__, __LINE__,FLAG)
|
||||
#define my_memdup(A,B,C) _my_memdup((A),(B), __FILE__,__LINE__,C)
|
||||
#define my_strdup(A,C) _my_strdup((A), __FILE__,__LINE__,C)
|
||||
#define my_strdup_with_length(A,B,C) _my_strdup_with_length((A),(B),__FILE__,__LINE__,C)
|
||||
#define TRASH(A,B) bfill(A, B, 0x8F)
|
||||
#define QUICK_SAFEMALLOC sf_malloc_quick=1
|
||||
#define NORMAL_SAFEMALLOC sf_malloc_quick=0
|
||||
extern uint sf_malloc_prehunc,sf_malloc_endhunc,sf_malloc_quick;
|
||||
extern ulonglong sf_malloc_mem_limit;
|
||||
|
||||
#define CALLER_INFO_PROTO , const char *sFile, uint uLine
|
||||
#define CALLER_INFO , __FILE__, __LINE__
|
||||
#define ORIG_CALLER_INFO , sFile, uLine
|
||||
#else
|
||||
#define my_checkmalloc()
|
||||
#undef TERMINATE
|
||||
#define TERMINATE(A) {}
|
||||
#define QUICK_SAFEMALLOC
|
||||
#define NORMAL_SAFEMALLOC
|
||||
extern gptr my_malloc(uint Size,myf MyFlags);
|
||||
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
|
||||
extern gptr my_realloc(gptr oldpoint,uint Size,myf MyFlags);
|
||||
extern void my_no_flags_free(gptr ptr);
|
||||
extern gptr my_memdup(const byte *from,uint length,myf MyFlags);
|
||||
extern char *my_strdup(const char *from,myf MyFlags);
|
||||
extern char *my_strdup_with_length(const byte *from, uint length,
|
||||
myf MyFlags);
|
||||
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
|
||||
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
|
||||
#define CALLER_INFO_PROTO /* nothing */
|
||||
#define CALLER_INFO /* nothing */
|
||||
#define ORIG_CALLER_INFO /* nothing */
|
||||
#define TRASH(A,B) /* nothing */
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_LARGE_PAGES
|
||||
extern uint my_get_large_page_size(void);
|
||||
extern gptr my_large_malloc(uint size, myf my_flags);
|
||||
extern void my_large_free(gptr ptr, myf my_flags);
|
||||
#else
|
||||
#define my_get_large_page_size() (0)
|
||||
#define my_large_malloc(A,B) my_malloc_lock((A),(B))
|
||||
#define my_large_free(A,B) my_free_lock((A),(B))
|
||||
#endif /* HAVE_LARGE_PAGES */
|
||||
|
||||
#ifdef HAVE_ALLOCA
|
||||
#if defined(_AIX) && !defined(__GNUC__) && !defined(_AIX43)
|
||||
#pragma alloca
|
||||
#endif /* _AIX */
|
||||
#if defined(__MWERKS__)
|
||||
#undef alloca
|
||||
#define alloca _alloca
|
||||
#endif /* __MWERKS__ */
|
||||
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
|
||||
#define alloca __builtin_alloca
|
||||
#endif /* GNUC */
|
||||
#define my_alloca(SZ) alloca((size_t) (SZ))
|
||||
#define my_afree(PTR) {}
|
||||
#else
|
||||
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
|
||||
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
|
||||
#endif /* HAVE_ALLOCA */
|
||||
|
||||
#ifdef MSDOS
|
||||
#ifdef __ZTC__
|
||||
void * __CDECL halloc(long count,size_t length);
|
||||
void __CDECL hfree(void *ptr);
|
||||
#endif
|
||||
#if defined(USE_HALLOC)
|
||||
#if defined(_VCM_) || defined(M_IC80386)
|
||||
#undef USE_HALLOC
|
||||
#endif
|
||||
#endif
|
||||
#ifdef USE_HALLOC
|
||||
#define malloc(a) halloc((long) (a),1)
|
||||
#define free(a) hfree(a)
|
||||
#endif
|
||||
#endif /* MSDOS */
|
||||
|
||||
#ifndef errno /* did we already get it? */
|
||||
#ifdef HAVE_ERRNO_AS_DEFINE
|
||||
#include <errno.h> /* errno is a define */
|
||||
#else
|
||||
extern int errno; /* declare errno */
|
||||
#endif
|
||||
#endif /* #ifndef errno */
|
||||
extern char NEAR errbuff[NRERRBUFFS][ERRMSGSIZE];
|
||||
extern char *home_dir; /* Home directory for user */
|
||||
extern const char *my_progname; /* program-name (printed in errors) */
|
||||
extern char NEAR curr_dir[]; /* Current directory for user */
|
||||
extern int (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
|
||||
extern int (*fatal_error_handler_hook)(uint my_err, const char *str,
|
||||
myf MyFlags);
|
||||
extern uint my_file_limit;
|
||||
|
||||
#ifdef HAVE_LARGE_PAGES
|
||||
extern my_bool my_use_large_pages;
|
||||
extern uint my_large_page_size;
|
||||
#endif
|
||||
|
||||
/* charsets */
|
||||
extern CHARSET_INFO *default_charset_info;
|
||||
extern CHARSET_INFO *all_charsets[256];
|
||||
extern CHARSET_INFO compiled_charsets[];
|
||||
|
||||
/* statistics */
|
||||
extern ulong my_file_opened,my_stream_opened, my_tmp_file_created;
|
||||
extern uint mysys_usage_id;
|
||||
extern my_bool my_init_done;
|
||||
|
||||
/* Point to current my_message() */
|
||||
extern void (*my_sigtstp_cleanup)(void),
|
||||
/* Executed before jump to shell */
|
||||
(*my_sigtstp_restart)(void),
|
||||
(*my_abort_hook)(int);
|
||||
/* Executed when comming from shell */
|
||||
extern int NEAR my_umask, /* Default creation mask */
|
||||
NEAR my_umask_dir,
|
||||
NEAR my_recived_signals, /* Signals we have got */
|
||||
NEAR my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
|
||||
NEAR my_dont_interrupt; /* call remember_intr when set */
|
||||
extern my_bool NEAR mysys_uses_curses, my_use_symdir;
|
||||
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
|
||||
|
||||
extern ulong my_default_record_cache_size;
|
||||
extern my_bool NEAR my_disable_locking,NEAR my_disable_async_io,
|
||||
NEAR my_disable_flush_key_blocks, NEAR my_disable_symlinks;
|
||||
extern char wild_many,wild_one,wild_prefix;
|
||||
extern const char *charsets_dir;
|
||||
extern char *defaults_extra_file;
|
||||
extern const char *defaults_group_suffix;
|
||||
extern const char *defaults_file;
|
||||
|
||||
extern my_bool timed_mutexes;
|
||||
|
||||
typedef struct wild_file_pack /* Struct to hold info when selecting files */
|
||||
{
|
||||
uint wilds; /* How many wildcards */
|
||||
uint not_pos; /* Start of not-theese-files */
|
||||
my_string *wild; /* Pointer to wildcards */
|
||||
} WF_PACK;
|
||||
|
||||
enum loglevel {
|
||||
ERROR_LEVEL,
|
||||
WARNING_LEVEL,
|
||||
INFORMATION_LEVEL
|
||||
};
|
||||
|
||||
enum cache_type
|
||||
{
|
||||
TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
|
||||
SEQ_READ_APPEND /* sequential read or append */,
|
||||
READ_FIFO, READ_NET,WRITE_NET};
|
||||
|
||||
enum flush_type
|
||||
{
|
||||
FLUSH_KEEP, FLUSH_RELEASE, FLUSH_IGNORE_CHANGED, FLUSH_FORCE_WRITE
|
||||
};
|
||||
|
||||
typedef struct st_record_cache /* Used when cacheing records */
|
||||
{
|
||||
File file;
|
||||
int rc_seek,error,inited;
|
||||
uint rc_length,read_length,reclength;
|
||||
my_off_t rc_record_pos,end_of_file;
|
||||
byte *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
|
||||
#ifdef HAVE_AIOWAIT
|
||||
int use_async_io;
|
||||
my_aio_result aio_result;
|
||||
#endif
|
||||
enum cache_type type;
|
||||
} RECORD_CACHE;
|
||||
|
||||
enum file_type
|
||||
{
|
||||
UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
|
||||
FILE_BY_MKSTEMP, FILE_BY_DUP
|
||||
};
|
||||
|
||||
struct st_my_file_info
|
||||
{
|
||||
my_string name;
|
||||
enum file_type type;
|
||||
#if defined(THREAD) && !defined(HAVE_PREAD)
|
||||
pthread_mutex_t mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
extern struct st_my_file_info *my_file_info;
|
||||
|
||||
typedef struct st_my_tmpdir
|
||||
{
|
||||
char **list;
|
||||
uint cur, max;
|
||||
#ifdef THREAD
|
||||
pthread_mutex_t mutex;
|
||||
#endif
|
||||
} MY_TMPDIR;
|
||||
|
||||
typedef struct st_dynamic_array
|
||||
{
|
||||
char *buffer;
|
||||
uint elements,max_element;
|
||||
uint alloc_increment;
|
||||
uint size_of_element;
|
||||
} DYNAMIC_ARRAY;
|
||||
|
||||
typedef struct st_dynamic_string
|
||||
{
|
||||
char *str;
|
||||
uint length,max_length,alloc_increment;
|
||||
} DYNAMIC_STRING;
|
||||
|
||||
struct st_io_cache;
|
||||
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
|
||||
|
||||
#ifdef THREAD
|
||||
typedef struct st_io_cache_share
|
||||
{
|
||||
/* to sync on reads into buffer */
|
||||
pthread_mutex_t mutex;
|
||||
pthread_cond_t cond;
|
||||
int count, total;
|
||||
/* actual IO_CACHE that filled the buffer */
|
||||
struct st_io_cache *active;
|
||||
#ifdef NOT_YET_IMPLEMENTED
|
||||
/* whether the structure should be free'd */
|
||||
my_bool alloced;
|
||||
#endif
|
||||
} IO_CACHE_SHARE;
|
||||
#endif
|
||||
|
||||
typedef struct st_io_cache /* Used when cacheing files */
|
||||
{
|
||||
/* Offset in file corresponding to the first byte of byte* buffer. */
|
||||
my_off_t pos_in_file;
|
||||
/*
|
||||
The offset of end of file for READ_CACHE and WRITE_CACHE.
|
||||
For SEQ_READ_APPEND it the maximum of the actual end of file and
|
||||
the position represented by read_end.
|
||||
*/
|
||||
my_off_t end_of_file;
|
||||
/* Points to current read position in the buffer */
|
||||
byte *read_pos;
|
||||
/* the non-inclusive boundary in the buffer for the currently valid read */
|
||||
byte *read_end;
|
||||
byte *buffer; /* The read buffer */
|
||||
/* Used in ASYNC_IO */
|
||||
byte *request_pos;
|
||||
|
||||
/* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
|
||||
byte *write_buffer;
|
||||
/*
|
||||
Only used in SEQ_READ_APPEND, and points to the current read position
|
||||
in the write buffer. Note that reads in SEQ_READ_APPEND caches can
|
||||
happen from both read buffer (byte* buffer) and write buffer
|
||||
(byte* write_buffer).
|
||||
*/
|
||||
byte *append_read_pos;
|
||||
/* Points to current write position in the write buffer */
|
||||
byte *write_pos;
|
||||
/* The non-inclusive boundary of the valid write area */
|
||||
byte *write_end;
|
||||
|
||||
/*
|
||||
Current_pos and current_end are convenience variables used by
|
||||
my_b_tell() and other routines that need to know the current offset
|
||||
current_pos points to &write_pos, and current_end to &write_end in a
|
||||
WRITE_CACHE, and &read_pos and &read_end respectively otherwise
|
||||
*/
|
||||
byte **current_pos, **current_end;
|
||||
#ifdef THREAD
|
||||
/*
|
||||
The lock is for append buffer used in SEQ_READ_APPEND cache
|
||||
need mutex copying from append buffer to read buffer.
|
||||
*/
|
||||
pthread_mutex_t append_buffer_lock;
|
||||
/*
|
||||
The following is used when several threads are reading the
|
||||
same file in parallel. They are synchronized on disk
|
||||
accesses reading the cached part of the file asynchronously.
|
||||
It should be set to NULL to disable the feature. Only
|
||||
READ_CACHE mode is supported.
|
||||
*/
|
||||
IO_CACHE_SHARE *share;
|
||||
#endif
|
||||
/*
|
||||
A caller will use my_b_read() macro to read from the cache
|
||||
if the data is already in cache, it will be simply copied with
|
||||
memcpy() and internal variables will be accordinging updated with
|
||||
no functions invoked. However, if the data is not fully in the cache,
|
||||
my_b_read() will call read_function to fetch the data. read_function
|
||||
must never be invoked directly.
|
||||
*/
|
||||
int (*read_function)(struct st_io_cache *,byte *,uint);
|
||||
/*
|
||||
Same idea as in the case of read_function, except my_b_write() needs to
|
||||
be replaced with my_b_append() for a SEQ_READ_APPEND cache
|
||||
*/
|
||||
int (*write_function)(struct st_io_cache *,const byte *,uint);
|
||||
/*
|
||||
Specifies the type of the cache. Depending on the type of the cache
|
||||
certain operations might not be available and yield unpredicatable
|
||||
results. Details to be documented later
|
||||
*/
|
||||
enum cache_type type;
|
||||
/*
|
||||
Callbacks when the actual read I/O happens. These were added and
|
||||
are currently used for binary logging of LOAD DATA INFILE - when a
|
||||
block is read from the file, we create a block create/append event, and
|
||||
when IO_CACHE is closed, we create an end event. These functions could,
|
||||
of course be used for other things
|
||||
*/
|
||||
IO_CACHE_CALLBACK pre_read;
|
||||
IO_CACHE_CALLBACK post_read;
|
||||
IO_CACHE_CALLBACK pre_close;
|
||||
/*
|
||||
Counts the number of times, when we were forced to use disk. We use it to
|
||||
increase the binlog_cache_disk_use status variable.
|
||||
*/
|
||||
ulong disk_writes;
|
||||
void* arg; /* for use by pre/post_read */
|
||||
char *file_name; /* if used with 'open_cached_file' */
|
||||
char *dir,*prefix;
|
||||
File file; /* file descriptor */
|
||||
/*
|
||||
seek_not_done is set by my_b_seek() to inform the upcoming read/write
|
||||
operation that a seek needs to be preformed prior to the actual I/O
|
||||
error is 0 if the cache operation was successful, -1 if there was a
|
||||
"hard" error, and the actual number of I/O-ed bytes if the read/write was
|
||||
partial.
|
||||
*/
|
||||
int seek_not_done,error;
|
||||
/* buffer_length is memory size allocated for buffer or write_buffer */
|
||||
uint buffer_length;
|
||||
/* read_length is the same as buffer_length except when we use async io */
|
||||
uint read_length;
|
||||
myf myflags; /* Flags used to my_read/my_write */
|
||||
/*
|
||||
alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
|
||||
0 if it was supplied by the user.
|
||||
Currently READ_NET is the only one that will use a buffer allocated
|
||||
somewhere else
|
||||
*/
|
||||
my_bool alloced_buffer;
|
||||
#ifdef HAVE_AIOWAIT
|
||||
/*
|
||||
As inidicated by ifdef, this is for async I/O, which is not currently
|
||||
used (because it's not reliable on all systems)
|
||||
*/
|
||||
uint inited;
|
||||
my_off_t aio_read_pos;
|
||||
my_aio_result aio_result;
|
||||
#endif
|
||||
} IO_CACHE;
|
||||
|
||||
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
|
||||
|
||||
/* defines for mf_iocache */
|
||||
|
||||
/* Test if buffer is inited */
|
||||
#define my_b_clear(info) (info)->buffer=0
|
||||
#define my_b_inited(info) (info)->buffer
|
||||
#define my_b_EOF INT_MIN
|
||||
|
||||
#define my_b_read(info,Buffer,Count) \
|
||||
((info)->read_pos + (Count) <= (info)->read_end ?\
|
||||
(memcpy(Buffer,(info)->read_pos,(size_t) (Count)), \
|
||||
((info)->read_pos+=(Count)),0) :\
|
||||
(*(info)->read_function)((info),Buffer,Count))
|
||||
|
||||
#define my_b_write(info,Buffer,Count) \
|
||||
((info)->write_pos + (Count) <=(info)->write_end ?\
|
||||
(memcpy((info)->write_pos, (Buffer), (size_t)(Count)),\
|
||||
((info)->write_pos+=(Count)),0) : \
|
||||
(*(info)->write_function)((info),(Buffer),(Count)))
|
||||
|
||||
#define my_b_get(info) \
|
||||
((info)->read_pos != (info)->read_end ?\
|
||||
((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
|
||||
_my_b_get(info))
|
||||
|
||||
/* my_b_write_byte dosn't have any err-check */
|
||||
#define my_b_write_byte(info,chr) \
|
||||
(((info)->write_pos < (info)->write_end) ?\
|
||||
((*(info)->write_pos++)=(chr)) :\
|
||||
(_my_b_write(info,0,0) , ((*(info)->write_pos++)=(chr))))
|
||||
|
||||
#define my_b_fill_cache(info) \
|
||||
(((info)->read_end=(info)->read_pos),(*(info)->read_function)(info,0,0))
|
||||
|
||||
#define my_b_tell(info) ((info)->pos_in_file + \
|
||||
(uint) (*(info)->current_pos - (info)->request_pos))
|
||||
|
||||
/* tell write offset in the SEQ_APPEND cache */
|
||||
my_off_t my_b_append_tell(IO_CACHE* info);
|
||||
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
|
||||
|
||||
#define my_b_bytes_in_cache(info) (uint) (*(info)->current_end - \
|
||||
*(info)->current_pos)
|
||||
|
||||
typedef uint32 ha_checksum;
|
||||
|
||||
/* Define the type of function to be passed to process_default_option_files */
|
||||
typedef int (*Process_option_func)(void *ctx, const char *group_name,
|
||||
const char *option);
|
||||
|
||||
#include <my_alloc.h>
|
||||
|
||||
/* Prototypes for mysys and my_func functions */
|
||||
|
||||
extern int my_copy(const char *from,const char *to,myf MyFlags);
|
||||
extern int my_append(const char *from,const char *to,myf MyFlags);
|
||||
extern int my_delete(const char *name,myf MyFlags);
|
||||
extern int my_getwd(my_string buf,uint size,myf MyFlags);
|
||||
extern int my_setwd(const char *dir,myf MyFlags);
|
||||
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
|
||||
extern gptr my_once_alloc(uint Size,myf MyFlags);
|
||||
extern void my_once_free(void);
|
||||
extern char *my_once_strdup(const char *src,myf myflags);
|
||||
extern char *my_once_memdup(const char *src, uint len, myf myflags);
|
||||
extern File my_open(const char *FileName,int Flags,myf MyFlags);
|
||||
extern File my_register_filename(File fd, const char *FileName,
|
||||
enum file_type type_of_file,
|
||||
uint error_message_number, myf MyFlags);
|
||||
extern File my_create(const char *FileName,int CreateFlags,
|
||||
int AccsesFlags, myf MyFlags);
|
||||
extern int my_close(File Filedes,myf MyFlags);
|
||||
extern File my_dup(File file, myf MyFlags);
|
||||
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
|
||||
extern int my_readlink(char *to, const char *filename, myf MyFlags);
|
||||
extern int my_realpath(char *to, const char *filename, myf MyFlags);
|
||||
extern File my_create_with_symlink(const char *linkname, const char *filename,
|
||||
int createflags, int access_flags,
|
||||
myf MyFlags);
|
||||
extern int my_delete_with_symlink(const char *name, myf MyFlags);
|
||||
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
|
||||
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
|
||||
extern uint my_read(File Filedes,byte *Buffer,uint Count,myf MyFlags);
|
||||
extern uint my_pread(File Filedes,byte *Buffer,uint Count,my_off_t offset,
|
||||
myf MyFlags);
|
||||
extern int my_rename(const char *from,const char *to,myf MyFlags);
|
||||
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
|
||||
extern my_off_t my_tell(File fd,myf MyFlags);
|
||||
extern uint my_write(File Filedes,const byte *Buffer,uint Count,
|
||||
myf MyFlags);
|
||||
extern uint my_pwrite(File Filedes,const byte *Buffer,uint Count,
|
||||
my_off_t offset,myf MyFlags);
|
||||
extern uint my_fread(FILE *stream,byte *Buffer,uint Count,myf MyFlags);
|
||||
extern uint my_fwrite(FILE *stream,const byte *Buffer,uint Count,
|
||||
myf MyFlags);
|
||||
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
|
||||
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
|
||||
extern gptr _mymalloc(uint uSize,const char *sFile,
|
||||
uint uLine, myf MyFlag);
|
||||
extern gptr _myrealloc(gptr pPtr,uint uSize,const char *sFile,
|
||||
uint uLine, myf MyFlag);
|
||||
extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...));
|
||||
extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag);
|
||||
extern int _sanity(const char *sFile,unsigned int uLine);
|
||||
extern gptr _my_memdup(const byte *from,uint length,
|
||||
const char *sFile, uint uLine,myf MyFlag);
|
||||
extern my_string _my_strdup(const char *from, const char *sFile, uint uLine,
|
||||
myf MyFlag);
|
||||
extern char *_my_strdup_with_length(const byte *from, uint length,
|
||||
const char *sFile, uint uLine,
|
||||
myf MyFlag);
|
||||
|
||||
#ifdef __WIN__
|
||||
extern int my_access(const char *path, int amode);
|
||||
#else
|
||||
#define my_access access
|
||||
#endif
|
||||
extern int check_if_legal_filename(const char *path);
|
||||
|
||||
#ifndef TERMINATE
|
||||
extern void TERMINATE(FILE *file);
|
||||
#endif
|
||||
extern void init_glob_errs(void);
|
||||
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
|
||||
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
|
||||
extern int my_fclose(FILE *fd,myf MyFlags);
|
||||
extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags);
|
||||
extern int my_sync(File fd, myf my_flags);
|
||||
extern int my_error _VARARGS((int nr,myf MyFlags, ...));
|
||||
extern int my_printf_error _VARARGS((uint my_err, const char *format,
|
||||
myf MyFlags, ...)
|
||||
__attribute__ ((format (printf, 2, 4))));
|
||||
extern int my_error_register(const char **errmsgs, int first, int last);
|
||||
extern const char **my_error_unregister(int first, int last);
|
||||
extern int my_message(uint my_err, const char *str,myf MyFlags);
|
||||
extern int my_message_no_curses(uint my_err, const char *str,myf MyFlags);
|
||||
extern int my_message_curses(uint my_err, const char *str,myf MyFlags);
|
||||
extern my_bool my_init(void);
|
||||
extern void my_end(int infoflag);
|
||||
extern int my_redel(const char *from, const char *to, int MyFlags);
|
||||
extern int my_copystat(const char *from, const char *to, int MyFlags);
|
||||
extern my_string my_filename(File fd);
|
||||
|
||||
#ifndef THREAD
|
||||
extern void dont_break(void);
|
||||
extern void allow_break(void);
|
||||
#else
|
||||
#define dont_break()
|
||||
#define allow_break()
|
||||
#endif
|
||||
|
||||
extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
|
||||
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
|
||||
extern void free_tmpdir(MY_TMPDIR *tmpdir);
|
||||
|
||||
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
|
||||
extern uint dirname_part(my_string to,const char *name);
|
||||
extern uint dirname_length(const char *name);
|
||||
#define base_name(A) (A+dirname_length(A))
|
||||
extern int test_if_hard_path(const char *dir_name);
|
||||
extern my_bool has_path(const char *name);
|
||||
extern char *convert_dirname(char *to, const char *from, const char *from_end);
|
||||
extern void to_unix_path(my_string name);
|
||||
extern my_string fn_ext(const char *name);
|
||||
extern my_string fn_same(my_string toname,const char *name,int flag);
|
||||
extern my_string fn_format(my_string to,const char *name,const char *dir,
|
||||
const char *form, uint flag);
|
||||
extern size_s strlength(const char *str);
|
||||
extern void pack_dirname(my_string to,const char *from);
|
||||
extern uint unpack_dirname(my_string to,const char *from);
|
||||
extern uint cleanup_dirname(my_string to,const char *from);
|
||||
extern uint system_filename(my_string to,const char *from);
|
||||
extern uint unpack_filename(my_string to,const char *from);
|
||||
extern my_string intern_filename(my_string to,const char *from);
|
||||
extern my_string directory_file_name(my_string dst, const char *src);
|
||||
extern int pack_filename(my_string to, const char *name, size_s max_length);
|
||||
extern my_string my_path(my_string to,const char *progname,
|
||||
const char *own_pathname_part);
|
||||
extern my_string my_load_path(my_string to, const char *path,
|
||||
const char *own_path_prefix);
|
||||
extern int wild_compare(const char *str,const char *wildstr,pbool str_is_pattern);
|
||||
extern WF_PACK *wf_comp(my_string str);
|
||||
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
|
||||
extern void wf_end(struct wild_file_pack *buffer);
|
||||
extern size_s strip_sp(my_string str);
|
||||
extern void get_date(my_string to,int timeflag,time_t use_time);
|
||||
extern void soundex(CHARSET_INFO *, my_string out_pntr, my_string in_pntr,pbool remove_garbage);
|
||||
extern int init_record_cache(RECORD_CACHE *info,uint cachesize,File file,
|
||||
uint reclength,enum cache_type type,
|
||||
pbool use_async_io);
|
||||
extern int read_cache_record(RECORD_CACHE *info,byte *to);
|
||||
extern int end_record_cache(RECORD_CACHE *info);
|
||||
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
|
||||
const byte *record,uint length);
|
||||
extern int flush_write_cache(RECORD_CACHE *info);
|
||||
extern long my_clock(void);
|
||||
extern sig_handler sigtstp_handler(int signal_number);
|
||||
extern void handle_recived_signals(void);
|
||||
|
||||
extern sig_handler my_set_alarm_variable(int signo);
|
||||
extern void my_string_ptr_sort(void *base,uint items,size_s size);
|
||||
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
|
||||
size_s size_of_element,uchar *buffer[]);
|
||||
extern qsort_t qsort2(void *base_ptr, size_t total_elems, size_t size,
|
||||
qsort2_cmp cmp, void *cmp_argument);
|
||||
extern qsort2_cmp get_ptr_compare(uint);
|
||||
void my_store_ptr(byte *buff, uint pack_length, my_off_t pos);
|
||||
my_off_t my_get_ptr(byte *ptr, uint pack_length);
|
||||
extern int init_io_cache(IO_CACHE *info,File file,uint cachesize,
|
||||
enum cache_type type,my_off_t seek_offset,
|
||||
pbool use_async_io, myf cache_myflags);
|
||||
extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
|
||||
my_off_t seek_offset,pbool use_async_io,
|
||||
pbool clear_cache);
|
||||
extern void setup_io_cache(IO_CACHE* info);
|
||||
extern int _my_b_read(IO_CACHE *info,byte *Buffer,uint Count);
|
||||
#ifdef THREAD
|
||||
extern int _my_b_read_r(IO_CACHE *info,byte *Buffer,uint Count);
|
||||
extern void init_io_cache_share(IO_CACHE *info,
|
||||
IO_CACHE_SHARE *s, uint num_threads);
|
||||
extern void remove_io_thread(IO_CACHE *info);
|
||||
#endif
|
||||
extern int _my_b_seq_read(IO_CACHE *info,byte *Buffer,uint Count);
|
||||
extern int _my_b_net_read(IO_CACHE *info,byte *Buffer,uint Count);
|
||||
extern int _my_b_get(IO_CACHE *info);
|
||||
extern int _my_b_async_read(IO_CACHE *info,byte *Buffer,uint Count);
|
||||
extern int _my_b_write(IO_CACHE *info,const byte *Buffer,uint Count);
|
||||
extern int my_b_append(IO_CACHE *info,const byte *Buffer,uint Count);
|
||||
extern int my_b_safe_write(IO_CACHE *info,const byte *Buffer,uint Count);
|
||||
|
||||
extern int my_block_write(IO_CACHE *info, const byte *Buffer,
|
||||
uint Count, my_off_t pos);
|
||||
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
|
||||
|
||||
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
|
||||
|
||||
extern int end_io_cache(IO_CACHE *info);
|
||||
extern uint my_b_fill(IO_CACHE *info);
|
||||
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
|
||||
extern uint my_b_gets(IO_CACHE *info, char *to, uint max_length);
|
||||
extern my_off_t my_b_filelength(IO_CACHE *info);
|
||||
extern uint my_b_printf(IO_CACHE *info, const char* fmt, ...);
|
||||
extern uint my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
|
||||
extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
|
||||
const char *prefix, uint cache_size,
|
||||
myf cache_myflags);
|
||||
extern my_bool real_open_cached_file(IO_CACHE *cache);
|
||||
extern void close_cached_file(IO_CACHE *cache);
|
||||
File create_temp_file(char *to, const char *dir, const char *pfx,
|
||||
int mode, myf MyFlags);
|
||||
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array(A,B,C,D CALLER_INFO)
|
||||
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array(A,B,C,D ORIG_CALLER_INFO)
|
||||
extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
|
||||
uint init_alloc,uint alloc_increment
|
||||
CALLER_INFO_PROTO);
|
||||
extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,gptr element);
|
||||
extern byte *alloc_dynamic(DYNAMIC_ARRAY *array);
|
||||
extern byte *pop_dynamic(DYNAMIC_ARRAY*);
|
||||
extern my_bool set_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index);
|
||||
extern void get_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index);
|
||||
extern void delete_dynamic(DYNAMIC_ARRAY *array);
|
||||
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
|
||||
extern void freeze_size(DYNAMIC_ARRAY *array);
|
||||
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
|
||||
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
|
||||
#define push_dynamic(A,B) insert_dynamic(A,B)
|
||||
#define reset_dynamic(array) ((array)->elements= 0)
|
||||
|
||||
extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
|
||||
uint init_alloc,uint alloc_increment);
|
||||
extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
|
||||
my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
|
||||
uint length);
|
||||
extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
|
||||
extern my_bool dynstr_realloc(DYNAMIC_STRING *str, ulong additional_size);
|
||||
extern void dynstr_free(DYNAMIC_STRING *str);
|
||||
#ifdef HAVE_MLOCK
|
||||
extern byte *my_malloc_lock(uint length,myf flags);
|
||||
extern void my_free_lock(byte *ptr,myf flags);
|
||||
#else
|
||||
#define my_malloc_lock(A,B) my_malloc((A),(B))
|
||||
#define my_free_lock(A,B) my_free((A),(B))
|
||||
#endif
|
||||
#define alloc_root_inited(A) ((A)->min_malloc != 0)
|
||||
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
|
||||
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
|
||||
extern void init_alloc_root(MEM_ROOT *mem_root, uint block_size,
|
||||
uint pre_alloc_size);
|
||||
extern gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size);
|
||||
extern gptr multi_alloc_root(MEM_ROOT *mem_root, ...);
|
||||
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
|
||||
extern void set_prealloc_root(MEM_ROOT *root, char *ptr);
|
||||
extern void reset_root_defaults(MEM_ROOT *mem_root, uint block_size,
|
||||
uint prealloc_size);
|
||||
extern char *strdup_root(MEM_ROOT *root,const char *str);
|
||||
extern char *strmake_root(MEM_ROOT *root,const char *str,uint len);
|
||||
extern char *memdup_root(MEM_ROOT *root,const char *str,uint len);
|
||||
extern int get_defaults_options(int argc, char **argv,
|
||||
char **defaults, char **extra_defaults,
|
||||
char **group_suffix);
|
||||
extern int load_defaults(const char *conf_file, const char **groups,
|
||||
int *argc, char ***argv);
|
||||
extern int modify_defaults_file(const char *file_location, const char *option,
|
||||
const char *option_value,
|
||||
const char *section_name, int remove_option);
|
||||
extern int my_search_option_files(const char *conf_file, int *argc,
|
||||
char ***argv, uint *args_used,
|
||||
Process_option_func func, void *func_ctx);
|
||||
extern void free_defaults(char **argv);
|
||||
extern void my_print_default_files(const char *conf_file);
|
||||
extern void print_defaults(const char *conf_file, const char **groups);
|
||||
extern my_bool my_compress(byte *, ulong *, ulong *);
|
||||
extern my_bool my_uncompress(byte *, ulong *, ulong *);
|
||||
extern byte *my_compress_alloc(const byte *packet, ulong *len, ulong *complen);
|
||||
extern ha_checksum my_checksum(ha_checksum crc, const byte *mem, uint count);
|
||||
extern uint my_bit_log2(ulong value);
|
||||
extern uint my_count_bits(ulonglong v);
|
||||
extern uint my_count_bits_ushort(ushort v);
|
||||
extern void my_sleep(ulong m_seconds);
|
||||
extern ulong crc32(ulong crc, const uchar *buf, uint len);
|
||||
extern uint my_set_max_open_files(uint files);
|
||||
void my_free_open_file_info(void);
|
||||
|
||||
ulonglong my_getsystime(void);
|
||||
my_bool my_gethwaddr(uchar *to);
|
||||
|
||||
#ifdef HAVE_SYS_MMAN_H
|
||||
#include <sys/mman.h>
|
||||
|
||||
#ifndef MAP_NOSYNC
|
||||
#define MAP_NOSYNC 0
|
||||
#endif
|
||||
|
||||
#define my_mmap(a,b,c,d,e,f) mmap(a,b,c,d,e,f)
|
||||
#ifdef HAVE_GETPAGESIZE
|
||||
#define my_getpagesize() getpagesize()
|
||||
#else
|
||||
/* qnx ? */
|
||||
#define my_getpagesize() 8192
|
||||
#endif
|
||||
#define my_munmap(a,b) munmap((a),(b))
|
||||
|
||||
#else
|
||||
/* not a complete set of mmap() flags, but only those that nesessary */
|
||||
#define PROT_READ 1
|
||||
#define PROT_WRITE 2
|
||||
#define MAP_SHARED 0x0001
|
||||
#define MAP_NOSYNC 0x0800
|
||||
#define MAP_FAILED ((void *)-1)
|
||||
#define MS_SYNC 0x0000
|
||||
|
||||
#ifndef __NETWARE__
|
||||
#define HAVE_MMAP
|
||||
#endif
|
||||
|
||||
int my_getpagesize(void);
|
||||
void *my_mmap(void *, size_t, int, int, int, my_off_t);
|
||||
int my_munmap(void *, size_t);
|
||||
#endif
|
||||
|
||||
int my_msync(int, void *, size_t, int);
|
||||
|
||||
/* character sets */
|
||||
extern uint get_charset_number(const char *cs_name, uint cs_flags);
|
||||
extern uint get_collation_number(const char *name);
|
||||
extern const char *get_charset_name(uint cs_number);
|
||||
|
||||
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
|
||||
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
|
||||
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
|
||||
uint cs_flags, myf my_flags);
|
||||
extern void free_charsets(void);
|
||||
extern char *get_charsets_dir(char *buf);
|
||||
extern my_bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2);
|
||||
extern my_bool init_compiled_charsets(myf flags);
|
||||
extern void add_compiled_collation(CHARSET_INFO *cs);
|
||||
extern ulong escape_string_for_mysql(CHARSET_INFO *charset_info,
|
||||
char *to, ulong to_length,
|
||||
const char *from, ulong length);
|
||||
#ifdef __WIN__
|
||||
#define BACKSLASH_MBTAIL
|
||||
/* File system character set */
|
||||
extern CHARSET_INFO *fs_character_set(void);
|
||||
#endif
|
||||
extern ulong escape_quotes_for_mysql(CHARSET_INFO *charset_info,
|
||||
char *to, ulong to_length,
|
||||
const char *from, ulong length);
|
||||
|
||||
extern void thd_increment_bytes_sent(ulong length);
|
||||
extern void thd_increment_bytes_received(ulong length);
|
||||
extern void thd_increment_net_big_packet_count(ulong length);
|
||||
|
||||
#ifdef __WIN__
|
||||
extern my_bool have_tcpip; /* Is set if tcpip is used */
|
||||
|
||||
/* implemented in my_windac.c */
|
||||
|
||||
int my_security_attr_create(SECURITY_ATTRIBUTES **psa, const char **perror,
|
||||
DWORD owner_rights, DWORD everybody_rights);
|
||||
|
||||
void my_security_attr_free(SECURITY_ATTRIBUTES *sa);
|
||||
|
||||
/* implemented in my_conio.c */
|
||||
char* my_cgets(char *string, unsigned long clen, unsigned long* plen);
|
||||
|
||||
#endif
|
||||
#ifdef __NETWARE__
|
||||
void netware_reg_user(const char *ip, const char *user,
|
||||
const char *application);
|
||||
#endif
|
||||
|
||||
C_MODE_END
|
||||
#include "raid.h"
|
||||
#endif /* _my_sys_h */
|
||||
Vendored
+839
@@ -0,0 +1,839 @@
|
||||
/* Copyright (C) 2000-2003 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#ifndef _mysql_h
|
||||
#define _mysql_h
|
||||
|
||||
#ifdef __CYGWIN__ /* CYGWIN implements a UNIX API */
|
||||
#undef WIN
|
||||
#undef _WIN
|
||||
#undef _WIN32
|
||||
#undef _WIN64
|
||||
#undef __WIN__
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _global_h /* If not standard header */
|
||||
#include <sys/types.h>
|
||||
#ifdef __LCC__
|
||||
#include <winsock.h> /* For windows */
|
||||
#endif
|
||||
typedef char my_bool;
|
||||
#if (defined(_WIN32) || defined(_WIN64)) && !defined(__WIN__)
|
||||
#define __WIN__
|
||||
#endif
|
||||
#if !defined(__WIN__)
|
||||
#define STDCALL
|
||||
#else
|
||||
#define STDCALL __stdcall
|
||||
#endif
|
||||
typedef char * gptr;
|
||||
|
||||
#ifndef my_socket_defined
|
||||
#ifdef __WIN__
|
||||
#define my_socket SOCKET
|
||||
#else
|
||||
typedef int my_socket;
|
||||
#endif /* __WIN__ */
|
||||
#endif /* my_socket_defined */
|
||||
#endif /* _global_h */
|
||||
|
||||
#include "mysql_com.h"
|
||||
#include "mysql_time.h"
|
||||
#include "mysql_version.h"
|
||||
#include "typelib.h"
|
||||
|
||||
#include "my_list.h" /* for LISTs used in 'MYSQL' and 'MYSQL_STMT' */
|
||||
|
||||
extern unsigned int mysql_port;
|
||||
extern char *mysql_unix_port;
|
||||
|
||||
#define CLIENT_NET_READ_TIMEOUT 365*24*3600 /* Timeout on read */
|
||||
#define CLIENT_NET_WRITE_TIMEOUT 365*24*3600 /* Timeout on write */
|
||||
|
||||
#ifdef __NETWARE__
|
||||
#pragma pack(push, 8) /* 8 byte alignment */
|
||||
#endif
|
||||
|
||||
#define IS_PRI_KEY(n) ((n) & PRI_KEY_FLAG)
|
||||
#define IS_NOT_NULL(n) ((n) & NOT_NULL_FLAG)
|
||||
#define IS_BLOB(n) ((n) & BLOB_FLAG)
|
||||
#define IS_NUM(t) ((t) <= FIELD_TYPE_INT24 || (t) == FIELD_TYPE_YEAR || (t) == FIELD_TYPE_NEWDECIMAL)
|
||||
#define IS_NUM_FIELD(f) ((f)->flags & NUM_FLAG)
|
||||
#define INTERNAL_NUM_FIELD(f) (((f)->type <= FIELD_TYPE_INT24 && ((f)->type != FIELD_TYPE_TIMESTAMP || (f)->length == 14 || (f)->length == 8)) || (f)->type == FIELD_TYPE_YEAR)
|
||||
|
||||
|
||||
typedef struct st_mysql_field {
|
||||
char *name; /* Name of column */
|
||||
char *org_name; /* Original column name, if an alias */
|
||||
char *table; /* Table of column if column was a field */
|
||||
char *org_table; /* Org table name, if table was an alias */
|
||||
char *db; /* Database for table */
|
||||
char *catalog; /* Catalog for table */
|
||||
char *def; /* Default value (set by mysql_list_fields) */
|
||||
unsigned long length; /* Width of column (create length) */
|
||||
unsigned long max_length; /* Max width for selected set */
|
||||
unsigned int name_length;
|
||||
unsigned int org_name_length;
|
||||
unsigned int table_length;
|
||||
unsigned int org_table_length;
|
||||
unsigned int db_length;
|
||||
unsigned int catalog_length;
|
||||
unsigned int def_length;
|
||||
unsigned int flags; /* Div flags */
|
||||
unsigned int decimals; /* Number of decimals in field */
|
||||
unsigned int charsetnr; /* Character set */
|
||||
enum enum_field_types type; /* Type of field. See mysql_com.h for types */
|
||||
} MYSQL_FIELD;
|
||||
|
||||
typedef char **MYSQL_ROW; /* return data as array of strings */
|
||||
typedef unsigned int MYSQL_FIELD_OFFSET; /* offset to current field */
|
||||
|
||||
#ifndef _global_h
|
||||
#if defined(NO_CLIENT_LONG_LONG)
|
||||
typedef unsigned long my_ulonglong;
|
||||
#elif defined (__WIN__)
|
||||
typedef unsigned __int64 my_ulonglong;
|
||||
#else
|
||||
typedef unsigned long long my_ulonglong;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define MYSQL_COUNT_ERROR (~(my_ulonglong) 0)
|
||||
|
||||
typedef struct st_mysql_rows {
|
||||
struct st_mysql_rows *next; /* list of rows */
|
||||
MYSQL_ROW data;
|
||||
unsigned long length;
|
||||
} MYSQL_ROWS;
|
||||
|
||||
typedef MYSQL_ROWS *MYSQL_ROW_OFFSET; /* offset to current row */
|
||||
|
||||
#include "my_alloc.h"
|
||||
|
||||
typedef struct st_mysql_data {
|
||||
my_ulonglong rows;
|
||||
unsigned int fields;
|
||||
MYSQL_ROWS *data;
|
||||
MEM_ROOT alloc;
|
||||
#if !defined(CHECK_EMBEDDED_DIFFERENCES) || defined(EMBEDDED_LIBRARY)
|
||||
MYSQL_ROWS **prev_ptr;
|
||||
#endif
|
||||
} MYSQL_DATA;
|
||||
|
||||
enum mysql_option
|
||||
{
|
||||
MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS, MYSQL_OPT_NAMED_PIPE,
|
||||
MYSQL_INIT_COMMAND, MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP,
|
||||
MYSQL_SET_CHARSET_DIR, MYSQL_SET_CHARSET_NAME, MYSQL_OPT_LOCAL_INFILE,
|
||||
MYSQL_OPT_PROTOCOL, MYSQL_SHARED_MEMORY_BASE_NAME, MYSQL_OPT_READ_TIMEOUT,
|
||||
MYSQL_OPT_WRITE_TIMEOUT, MYSQL_OPT_USE_RESULT,
|
||||
MYSQL_OPT_USE_REMOTE_CONNECTION, MYSQL_OPT_USE_EMBEDDED_CONNECTION,
|
||||
MYSQL_OPT_GUESS_CONNECTION, MYSQL_SET_CLIENT_IP, MYSQL_SECURE_AUTH,
|
||||
MYSQL_REPORT_DATA_TRUNCATION, MYSQL_OPT_RECONNECT
|
||||
};
|
||||
|
||||
struct st_mysql_options {
|
||||
unsigned int connect_timeout, read_timeout, write_timeout;
|
||||
unsigned int port, protocol;
|
||||
unsigned long client_flag;
|
||||
char *host,*user,*password,*unix_socket,*db;
|
||||
struct st_dynamic_array *init_commands;
|
||||
char *my_cnf_file,*my_cnf_group, *charset_dir, *charset_name;
|
||||
char *ssl_key; /* PEM key file */
|
||||
char *ssl_cert; /* PEM cert file */
|
||||
char *ssl_ca; /* PEM CA file */
|
||||
char *ssl_capath; /* PEM directory of CA-s? */
|
||||
char *ssl_cipher; /* cipher to use */
|
||||
char *shared_memory_base_name;
|
||||
unsigned long max_allowed_packet;
|
||||
my_bool use_ssl; /* if to use SSL or not */
|
||||
my_bool compress,named_pipe;
|
||||
/*
|
||||
On connect, find out the replication role of the server, and
|
||||
establish connections to all the peers
|
||||
*/
|
||||
my_bool rpl_probe;
|
||||
/*
|
||||
Each call to mysql_real_query() will parse it to tell if it is a read
|
||||
or a write, and direct it to the slave or the master
|
||||
*/
|
||||
my_bool rpl_parse;
|
||||
/*
|
||||
If set, never read from a master, only from slave, when doing
|
||||
a read that is replication-aware
|
||||
*/
|
||||
my_bool no_master_reads;
|
||||
#if !defined(CHECK_EMBEDDED_DIFFERENCES) || defined(EMBEDDED_LIBRARY)
|
||||
my_bool separate_thread;
|
||||
#endif
|
||||
enum mysql_option methods_to_use;
|
||||
char *client_ip;
|
||||
/* Refuse client connecting to server if it uses old (pre-4.1.1) protocol */
|
||||
my_bool secure_auth;
|
||||
/* 0 - never report, 1 - always report (default) */
|
||||
my_bool report_data_truncation;
|
||||
|
||||
/* function pointers for local infile support */
|
||||
int (*local_infile_init)(void **, const char *, void *);
|
||||
int (*local_infile_read)(void *, char *, unsigned int);
|
||||
void (*local_infile_end)(void *);
|
||||
int (*local_infile_error)(void *, char *, unsigned int);
|
||||
void *local_infile_userdata;
|
||||
};
|
||||
|
||||
enum mysql_status
|
||||
{
|
||||
MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,MYSQL_STATUS_USE_RESULT
|
||||
};
|
||||
|
||||
enum mysql_protocol_type
|
||||
{
|
||||
MYSQL_PROTOCOL_DEFAULT, MYSQL_PROTOCOL_TCP, MYSQL_PROTOCOL_SOCKET,
|
||||
MYSQL_PROTOCOL_PIPE, MYSQL_PROTOCOL_MEMORY
|
||||
};
|
||||
/*
|
||||
There are three types of queries - the ones that have to go to
|
||||
the master, the ones that go to a slave, and the adminstrative
|
||||
type which must happen on the pivot connectioin
|
||||
*/
|
||||
enum mysql_rpl_type
|
||||
{
|
||||
MYSQL_RPL_MASTER, MYSQL_RPL_SLAVE, MYSQL_RPL_ADMIN
|
||||
};
|
||||
|
||||
typedef struct character_set
|
||||
{
|
||||
unsigned int number; /* character set number */
|
||||
unsigned int state; /* character set state */
|
||||
const char *csname; /* collation name */
|
||||
const char *name; /* character set name */
|
||||
const char *comment; /* comment */
|
||||
const char *dir; /* character set directory */
|
||||
unsigned int mbminlen; /* min. length for multibyte strings */
|
||||
unsigned int mbmaxlen; /* max. length for multibyte strings */
|
||||
} MY_CHARSET_INFO;
|
||||
|
||||
struct st_mysql_methods;
|
||||
|
||||
typedef struct st_mysql
|
||||
{
|
||||
NET net; /* Communication parameters */
|
||||
gptr connector_fd; /* ConnectorFd for SSL */
|
||||
char *host,*user,*passwd,*unix_socket,*server_version,*host_info,*info;
|
||||
char *db;
|
||||
struct charset_info_st *charset;
|
||||
MYSQL_FIELD *fields;
|
||||
MEM_ROOT field_alloc;
|
||||
my_ulonglong affected_rows;
|
||||
my_ulonglong insert_id; /* id if insert on table with NEXTNR */
|
||||
my_ulonglong extra_info; /* Not used */
|
||||
unsigned long thread_id; /* Id for connection in server */
|
||||
unsigned long packet_length;
|
||||
unsigned int port;
|
||||
unsigned long client_flag,server_capabilities;
|
||||
unsigned int protocol_version;
|
||||
unsigned int field_count;
|
||||
unsigned int server_status;
|
||||
unsigned int server_language;
|
||||
unsigned int warning_count;
|
||||
struct st_mysql_options options;
|
||||
enum mysql_status status;
|
||||
my_bool free_me; /* If free in mysql_close */
|
||||
my_bool reconnect; /* set to 1 if automatic reconnect */
|
||||
|
||||
/* session-wide random string */
|
||||
char scramble[SCRAMBLE_LENGTH+1];
|
||||
|
||||
/*
|
||||
Set if this is the original connection, not a master or a slave we have
|
||||
added though mysql_rpl_probe() or mysql_set_master()/ mysql_add_slave()
|
||||
*/
|
||||
my_bool rpl_pivot;
|
||||
/*
|
||||
Pointers to the master, and the next slave connections, points to
|
||||
itself if lone connection.
|
||||
*/
|
||||
struct st_mysql* master, *next_slave;
|
||||
|
||||
struct st_mysql* last_used_slave; /* needed for round-robin slave pick */
|
||||
/* needed for send/read/store/use result to work correctly with replication */
|
||||
struct st_mysql* last_used_con;
|
||||
|
||||
LIST *stmts; /* list of all statements */
|
||||
const struct st_mysql_methods *methods;
|
||||
void *thd;
|
||||
/*
|
||||
Points to boolean flag in MYSQL_RES or MYSQL_STMT. We set this flag
|
||||
from mysql_stmt_close if close had to cancel result set of this object.
|
||||
*/
|
||||
my_bool *unbuffered_fetch_owner;
|
||||
} MYSQL;
|
||||
|
||||
typedef struct st_mysql_res {
|
||||
my_ulonglong row_count;
|
||||
MYSQL_FIELD *fields;
|
||||
MYSQL_DATA *data;
|
||||
MYSQL_ROWS *data_cursor;
|
||||
unsigned long *lengths; /* column lengths of current row */
|
||||
MYSQL *handle; /* for unbuffered reads */
|
||||
MEM_ROOT field_alloc;
|
||||
unsigned int field_count, current_field;
|
||||
MYSQL_ROW row; /* If unbuffered read */
|
||||
MYSQL_ROW current_row; /* buffer to current row */
|
||||
my_bool eof; /* Used by mysql_fetch_row */
|
||||
/* mysql_stmt_close() had to cancel this result */
|
||||
my_bool unbuffered_fetch_cancelled;
|
||||
const struct st_mysql_methods *methods;
|
||||
} MYSQL_RES;
|
||||
|
||||
#define MAX_MYSQL_MANAGER_ERR 256
|
||||
#define MAX_MYSQL_MANAGER_MSG 256
|
||||
|
||||
#define MANAGER_OK 200
|
||||
#define MANAGER_INFO 250
|
||||
#define MANAGER_ACCESS 401
|
||||
#define MANAGER_CLIENT_ERR 450
|
||||
#define MANAGER_INTERNAL_ERR 500
|
||||
|
||||
#if !defined(MYSQL_SERVER) && !defined(MYSQL_CLIENT)
|
||||
#define MYSQL_CLIENT
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct st_mysql_manager
|
||||
{
|
||||
NET net;
|
||||
char *host,*user,*passwd;
|
||||
unsigned int port;
|
||||
my_bool free_me;
|
||||
my_bool eof;
|
||||
int cmd_status;
|
||||
int last_errno;
|
||||
char* net_buf,*net_buf_pos,*net_data_end;
|
||||
int net_buf_size;
|
||||
char last_error[MAX_MYSQL_MANAGER_ERR];
|
||||
} MYSQL_MANAGER;
|
||||
|
||||
typedef struct st_mysql_parameters
|
||||
{
|
||||
unsigned long *p_max_allowed_packet;
|
||||
unsigned long *p_net_buffer_length;
|
||||
} MYSQL_PARAMETERS;
|
||||
|
||||
#if !defined(MYSQL_SERVER) && !defined(EMBEDDED_LIBRARY)
|
||||
#define max_allowed_packet (*mysql_get_parameters()->p_max_allowed_packet)
|
||||
#define net_buffer_length (*mysql_get_parameters()->p_net_buffer_length)
|
||||
#endif
|
||||
|
||||
/*
|
||||
Set up and bring down the server; to ensure that applications will
|
||||
work when linked against either the standard client library or the
|
||||
embedded server library, these functions should be called.
|
||||
*/
|
||||
int STDCALL mysql_server_init(int argc, char **argv, char **groups);
|
||||
void STDCALL mysql_server_end(void);
|
||||
/*
|
||||
mysql_server_init/end need to be called when using libmysqld or
|
||||
libmysqlclient (exactly, mysql_server_init() is called by mysql_init() so
|
||||
you don't need to call it explicitely; but you need to call
|
||||
mysql_server_end() to free memory). The names are a bit misleading
|
||||
(mysql_SERVER* to be used when using libmysqlCLIENT). So we add more general
|
||||
names which suit well whether you're using libmysqld or libmysqlclient. We
|
||||
intend to promote these aliases over the mysql_server* ones.
|
||||
*/
|
||||
#define mysql_library_init mysql_server_init
|
||||
#define mysql_library_end mysql_server_end
|
||||
|
||||
MYSQL_PARAMETERS *STDCALL mysql_get_parameters(void);
|
||||
|
||||
/*
|
||||
Set up and bring down a thread; these function should be called
|
||||
for each thread in an application which opens at least one MySQL
|
||||
connection. All uses of the connection(s) should be between these
|
||||
function calls.
|
||||
*/
|
||||
my_bool STDCALL mysql_thread_init(void);
|
||||
void STDCALL mysql_thread_end(void);
|
||||
|
||||
/*
|
||||
Functions to get information from the MYSQL and MYSQL_RES structures
|
||||
Should definitely be used if one uses shared libraries.
|
||||
*/
|
||||
|
||||
my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res);
|
||||
unsigned int STDCALL mysql_num_fields(MYSQL_RES *res);
|
||||
my_bool STDCALL mysql_eof(MYSQL_RES *res);
|
||||
MYSQL_FIELD *STDCALL mysql_fetch_field_direct(MYSQL_RES *res,
|
||||
unsigned int fieldnr);
|
||||
MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res);
|
||||
MYSQL_ROW_OFFSET STDCALL mysql_row_tell(MYSQL_RES *res);
|
||||
MYSQL_FIELD_OFFSET STDCALL mysql_field_tell(MYSQL_RES *res);
|
||||
|
||||
unsigned int STDCALL mysql_field_count(MYSQL *mysql);
|
||||
my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql);
|
||||
my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql);
|
||||
unsigned int STDCALL mysql_errno(MYSQL *mysql);
|
||||
const char * STDCALL mysql_error(MYSQL *mysql);
|
||||
const char *STDCALL mysql_sqlstate(MYSQL *mysql);
|
||||
unsigned int STDCALL mysql_warning_count(MYSQL *mysql);
|
||||
const char * STDCALL mysql_info(MYSQL *mysql);
|
||||
unsigned long STDCALL mysql_thread_id(MYSQL *mysql);
|
||||
const char * STDCALL mysql_character_set_name(MYSQL *mysql);
|
||||
int STDCALL mysql_set_character_set(MYSQL *mysql, const char *csname);
|
||||
|
||||
MYSQL * STDCALL mysql_init(MYSQL *mysql);
|
||||
my_bool STDCALL mysql_ssl_set(MYSQL *mysql, const char *key,
|
||||
const char *cert, const char *ca,
|
||||
const char *capath, const char *cipher);
|
||||
my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
|
||||
const char *passwd, const char *db);
|
||||
MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host,
|
||||
const char *user,
|
||||
const char *passwd,
|
||||
const char *db,
|
||||
unsigned int port,
|
||||
const char *unix_socket,
|
||||
unsigned long clientflag);
|
||||
int STDCALL mysql_select_db(MYSQL *mysql, const char *db);
|
||||
int STDCALL mysql_query(MYSQL *mysql, const char *q);
|
||||
int STDCALL mysql_send_query(MYSQL *mysql, const char *q,
|
||||
unsigned long length);
|
||||
int STDCALL mysql_real_query(MYSQL *mysql, const char *q,
|
||||
unsigned long length);
|
||||
MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql);
|
||||
MYSQL_RES * STDCALL mysql_use_result(MYSQL *mysql);
|
||||
|
||||
/* perform query on master */
|
||||
my_bool STDCALL mysql_master_query(MYSQL *mysql, const char *q,
|
||||
unsigned long length);
|
||||
my_bool STDCALL mysql_master_send_query(MYSQL *mysql, const char *q,
|
||||
unsigned long length);
|
||||
/* perform query on slave */
|
||||
my_bool STDCALL mysql_slave_query(MYSQL *mysql, const char *q,
|
||||
unsigned long length);
|
||||
my_bool STDCALL mysql_slave_send_query(MYSQL *mysql, const char *q,
|
||||
unsigned long length);
|
||||
void STDCALL mysql_get_character_set_info(MYSQL *mysql,
|
||||
MY_CHARSET_INFO *charset);
|
||||
|
||||
/* local infile support */
|
||||
|
||||
#define LOCAL_INFILE_ERROR_LEN 512
|
||||
|
||||
void
|
||||
mysql_set_local_infile_handler(MYSQL *mysql,
|
||||
int (*local_infile_init)(void **, const char *,
|
||||
void *),
|
||||
int (*local_infile_read)(void *, char *,
|
||||
unsigned int),
|
||||
void (*local_infile_end)(void *),
|
||||
int (*local_infile_error)(void *, char*,
|
||||
unsigned int),
|
||||
void *);
|
||||
|
||||
void
|
||||
mysql_set_local_infile_default(MYSQL *mysql);
|
||||
|
||||
|
||||
/*
|
||||
enable/disable parsing of all queries to decide if they go on master or
|
||||
slave
|
||||
*/
|
||||
void STDCALL mysql_enable_rpl_parse(MYSQL* mysql);
|
||||
void STDCALL mysql_disable_rpl_parse(MYSQL* mysql);
|
||||
/* get the value of the parse flag */
|
||||
int STDCALL mysql_rpl_parse_enabled(MYSQL* mysql);
|
||||
|
||||
/* enable/disable reads from master */
|
||||
void STDCALL mysql_enable_reads_from_master(MYSQL* mysql);
|
||||
void STDCALL mysql_disable_reads_from_master(MYSQL* mysql);
|
||||
/* get the value of the master read flag */
|
||||
my_bool STDCALL mysql_reads_from_master_enabled(MYSQL* mysql);
|
||||
|
||||
enum mysql_rpl_type STDCALL mysql_rpl_query_type(const char* q, int len);
|
||||
|
||||
/* discover the master and its slaves */
|
||||
my_bool STDCALL mysql_rpl_probe(MYSQL* mysql);
|
||||
|
||||
/* set the master, close/free the old one, if it is not a pivot */
|
||||
int STDCALL mysql_set_master(MYSQL* mysql, const char* host,
|
||||
unsigned int port,
|
||||
const char* user,
|
||||
const char* passwd);
|
||||
int STDCALL mysql_add_slave(MYSQL* mysql, const char* host,
|
||||
unsigned int port,
|
||||
const char* user,
|
||||
const char* passwd);
|
||||
|
||||
int STDCALL mysql_shutdown(MYSQL *mysql,
|
||||
enum mysql_enum_shutdown_level
|
||||
shutdown_level);
|
||||
int STDCALL mysql_dump_debug_info(MYSQL *mysql);
|
||||
int STDCALL mysql_refresh(MYSQL *mysql,
|
||||
unsigned int refresh_options);
|
||||
int STDCALL mysql_kill(MYSQL *mysql,unsigned long pid);
|
||||
int STDCALL mysql_set_server_option(MYSQL *mysql,
|
||||
enum enum_mysql_set_option
|
||||
option);
|
||||
int STDCALL mysql_ping(MYSQL *mysql);
|
||||
const char * STDCALL mysql_stat(MYSQL *mysql);
|
||||
const char * STDCALL mysql_get_server_info(MYSQL *mysql);
|
||||
const char * STDCALL mysql_get_client_info(void);
|
||||
unsigned long STDCALL mysql_get_client_version(void);
|
||||
const char * STDCALL mysql_get_host_info(MYSQL *mysql);
|
||||
unsigned long STDCALL mysql_get_server_version(MYSQL *mysql);
|
||||
unsigned int STDCALL mysql_get_proto_info(MYSQL *mysql);
|
||||
MYSQL_RES * STDCALL mysql_list_dbs(MYSQL *mysql,const char *wild);
|
||||
MYSQL_RES * STDCALL mysql_list_tables(MYSQL *mysql,const char *wild);
|
||||
MYSQL_RES * STDCALL mysql_list_processes(MYSQL *mysql);
|
||||
int STDCALL mysql_options(MYSQL *mysql,enum mysql_option option,
|
||||
const char *arg);
|
||||
void STDCALL mysql_free_result(MYSQL_RES *result);
|
||||
void STDCALL mysql_data_seek(MYSQL_RES *result,
|
||||
my_ulonglong offset);
|
||||
MYSQL_ROW_OFFSET STDCALL mysql_row_seek(MYSQL_RES *result,
|
||||
MYSQL_ROW_OFFSET offset);
|
||||
MYSQL_FIELD_OFFSET STDCALL mysql_field_seek(MYSQL_RES *result,
|
||||
MYSQL_FIELD_OFFSET offset);
|
||||
MYSQL_ROW STDCALL mysql_fetch_row(MYSQL_RES *result);
|
||||
unsigned long * STDCALL mysql_fetch_lengths(MYSQL_RES *result);
|
||||
MYSQL_FIELD * STDCALL mysql_fetch_field(MYSQL_RES *result);
|
||||
MYSQL_RES * STDCALL mysql_list_fields(MYSQL *mysql, const char *table,
|
||||
const char *wild);
|
||||
unsigned long STDCALL mysql_escape_string(char *to,const char *from,
|
||||
unsigned long from_length);
|
||||
unsigned long STDCALL mysql_hex_string(char *to,const char *from,
|
||||
unsigned long from_length);
|
||||
unsigned long STDCALL mysql_real_escape_string(MYSQL *mysql,
|
||||
char *to,const char *from,
|
||||
unsigned long length);
|
||||
void STDCALL mysql_debug(const char *debug);
|
||||
char * STDCALL mysql_odbc_escape_string(MYSQL *mysql,
|
||||
char *to,
|
||||
unsigned long to_length,
|
||||
const char *from,
|
||||
unsigned long from_length,
|
||||
void *param,
|
||||
char *
|
||||
(*extend_buffer)
|
||||
(void *, char *to,
|
||||
unsigned long *length));
|
||||
void STDCALL myodbc_remove_escape(MYSQL *mysql,char *name);
|
||||
unsigned int STDCALL mysql_thread_safe(void);
|
||||
my_bool STDCALL mysql_embedded(void);
|
||||
MYSQL_MANAGER* STDCALL mysql_manager_init(MYSQL_MANAGER* con);
|
||||
MYSQL_MANAGER* STDCALL mysql_manager_connect(MYSQL_MANAGER* con,
|
||||
const char* host,
|
||||
const char* user,
|
||||
const char* passwd,
|
||||
unsigned int port);
|
||||
void STDCALL mysql_manager_close(MYSQL_MANAGER* con);
|
||||
int STDCALL mysql_manager_command(MYSQL_MANAGER* con,
|
||||
const char* cmd, int cmd_len);
|
||||
int STDCALL mysql_manager_fetch_line(MYSQL_MANAGER* con,
|
||||
char* res_buf,
|
||||
int res_buf_size);
|
||||
my_bool STDCALL mysql_read_query_result(MYSQL *mysql);
|
||||
|
||||
|
||||
/*
|
||||
The following definitions are added for the enhanced
|
||||
client-server protocol
|
||||
*/
|
||||
|
||||
/* statement state */
|
||||
enum enum_mysql_stmt_state
|
||||
{
|
||||
MYSQL_STMT_INIT_DONE= 1, MYSQL_STMT_PREPARE_DONE, MYSQL_STMT_EXECUTE_DONE,
|
||||
MYSQL_STMT_FETCH_DONE
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
This structure is used to define bind information, and
|
||||
internally by the client library.
|
||||
Public members with their descriptions are listed below
|
||||
(conventionally `On input' refers to the binds given to
|
||||
mysql_stmt_bind_param, `On output' refers to the binds given
|
||||
to mysql_stmt_bind_result):
|
||||
|
||||
buffer_type - One of the MYSQL_* types, used to describe
|
||||
the host language type of buffer.
|
||||
On output: if column type is different from
|
||||
buffer_type, column value is automatically converted
|
||||
to buffer_type before it is stored in the buffer.
|
||||
buffer - On input: points to the buffer with input data.
|
||||
On output: points to the buffer capable to store
|
||||
output data.
|
||||
The type of memory pointed by buffer must correspond
|
||||
to buffer_type. See the correspondence table in
|
||||
the comment to mysql_stmt_bind_param.
|
||||
|
||||
The two above members are mandatory for any kind of bind.
|
||||
|
||||
buffer_length - the length of the buffer. You don't have to set
|
||||
it for any fixed length buffer: float, double,
|
||||
int, etc. It must be set however for variable-length
|
||||
types, such as BLOBs or STRINGs.
|
||||
|
||||
length - On input: in case when lengths of input values
|
||||
are different for each execute, you can set this to
|
||||
point at a variable containining value length. This
|
||||
way the value length can be different in each execute.
|
||||
If length is not NULL, buffer_length is not used.
|
||||
Note, length can even point at buffer_length if
|
||||
you keep bind structures around while fetching:
|
||||
this way you can change buffer_length before
|
||||
each execution, everything will work ok.
|
||||
On output: if length is set, mysql_stmt_fetch will
|
||||
write column length into it.
|
||||
|
||||
is_null - On input: points to a boolean variable that should
|
||||
be set to TRUE for NULL values.
|
||||
This member is useful only if your data may be
|
||||
NULL in some but not all cases.
|
||||
If your data is never NULL, is_null should be set to 0.
|
||||
If your data is always NULL, set buffer_type
|
||||
to MYSQL_TYPE_NULL, and is_null will not be used.
|
||||
|
||||
is_unsigned - On input: used to signify that values provided for one
|
||||
of numeric types are unsigned.
|
||||
On output describes signedness of the output buffer.
|
||||
If, taking into account is_unsigned flag, column data
|
||||
is out of range of the output buffer, data for this column
|
||||
is regarded truncated. Note that this has no correspondence
|
||||
to the sign of result set column, if you need to find it out
|
||||
use mysql_stmt_result_metadata.
|
||||
error - where to write a truncation error if it is present.
|
||||
possible error value is:
|
||||
0 no truncation
|
||||
1 value is out of range or buffer is too small
|
||||
|
||||
Please note that MYSQL_BIND also has internals members.
|
||||
*/
|
||||
|
||||
typedef struct st_mysql_bind
|
||||
{
|
||||
unsigned long *length; /* output length pointer */
|
||||
my_bool *is_null; /* Pointer to null indicator */
|
||||
void *buffer; /* buffer to get/put data */
|
||||
/* set this if you want to track data truncations happened during fetch */
|
||||
my_bool *error;
|
||||
enum enum_field_types buffer_type; /* buffer type */
|
||||
/* output buffer length, must be set when fetching str/binary */
|
||||
unsigned long buffer_length;
|
||||
unsigned char *row_ptr; /* for the current data position */
|
||||
unsigned long offset; /* offset position for char/binary fetch */
|
||||
unsigned long length_value; /* Used if length is 0 */
|
||||
unsigned int param_number; /* For null count and error messages */
|
||||
unsigned int pack_length; /* Internal length for packed data */
|
||||
my_bool error_value; /* used if error is 0 */
|
||||
my_bool is_unsigned; /* set if integer type is unsigned */
|
||||
my_bool long_data_used; /* If used with mysql_send_long_data */
|
||||
my_bool is_null_value; /* Used if is_null is 0 */
|
||||
void (*store_param_func)(NET *net, struct st_mysql_bind *param);
|
||||
void (*fetch_result)(struct st_mysql_bind *, MYSQL_FIELD *,
|
||||
unsigned char **row);
|
||||
void (*skip_result)(struct st_mysql_bind *, MYSQL_FIELD *,
|
||||
unsigned char **row);
|
||||
} MYSQL_BIND;
|
||||
|
||||
|
||||
/* statement handler */
|
||||
typedef struct st_mysql_stmt
|
||||
{
|
||||
MEM_ROOT mem_root; /* root allocations */
|
||||
LIST list; /* list to keep track of all stmts */
|
||||
MYSQL *mysql; /* connection handle */
|
||||
MYSQL_BIND *params; /* input parameters */
|
||||
MYSQL_BIND *bind; /* output parameters */
|
||||
MYSQL_FIELD *fields; /* result set metadata */
|
||||
MYSQL_DATA result; /* cached result set */
|
||||
MYSQL_ROWS *data_cursor; /* current row in cached result */
|
||||
/* copy of mysql->affected_rows after statement execution */
|
||||
my_ulonglong affected_rows;
|
||||
my_ulonglong insert_id; /* copy of mysql->insert_id */
|
||||
/*
|
||||
mysql_stmt_fetch() calls this function to fetch one row (it's different
|
||||
for buffered, unbuffered and cursor fetch).
|
||||
*/
|
||||
int (*read_row_func)(struct st_mysql_stmt *stmt,
|
||||
unsigned char **row);
|
||||
unsigned long stmt_id; /* Id for prepared statement */
|
||||
unsigned long flags; /* i.e. type of cursor to open */
|
||||
unsigned long prefetch_rows; /* number of rows per one COM_FETCH */
|
||||
/*
|
||||
Copied from mysql->server_status after execute/fetch to know
|
||||
server-side cursor status for this statement.
|
||||
*/
|
||||
unsigned int server_status;
|
||||
unsigned int last_errno; /* error code */
|
||||
unsigned int param_count; /* input parameter count */
|
||||
unsigned int field_count; /* number of columns in result set */
|
||||
enum enum_mysql_stmt_state state; /* statement state */
|
||||
char last_error[MYSQL_ERRMSG_SIZE]; /* error message */
|
||||
char sqlstate[SQLSTATE_LENGTH+1];
|
||||
/* Types of input parameters should be sent to server */
|
||||
my_bool send_types_to_server;
|
||||
my_bool bind_param_done; /* input buffers were supplied */
|
||||
unsigned char bind_result_done; /* output buffers were supplied */
|
||||
/* mysql_stmt_close() had to cancel this result */
|
||||
my_bool unbuffered_fetch_cancelled;
|
||||
/*
|
||||
Is set to true if we need to calculate field->max_length for
|
||||
metadata fields when doing mysql_stmt_store_result.
|
||||
*/
|
||||
my_bool update_max_length;
|
||||
} MYSQL_STMT;
|
||||
|
||||
enum enum_stmt_attr_type
|
||||
{
|
||||
/*
|
||||
When doing mysql_stmt_store_result calculate max_length attribute
|
||||
of statement metadata. This is to be consistent with the old API,
|
||||
where this was done automatically.
|
||||
In the new API we do that only by request because it slows down
|
||||
mysql_stmt_store_result sufficiently.
|
||||
*/
|
||||
STMT_ATTR_UPDATE_MAX_LENGTH,
|
||||
/*
|
||||
unsigned long with combination of cursor flags (read only, for update,
|
||||
etc)
|
||||
*/
|
||||
STMT_ATTR_CURSOR_TYPE,
|
||||
/*
|
||||
Amount of rows to retrieve from server per one fetch if using cursors.
|
||||
Accepts unsigned long attribute in the range 1 - ulong_max
|
||||
*/
|
||||
STMT_ATTR_PREFETCH_ROWS
|
||||
};
|
||||
|
||||
|
||||
typedef struct st_mysql_methods
|
||||
{
|
||||
my_bool (*read_query_result)(MYSQL *mysql);
|
||||
my_bool (*advanced_command)(MYSQL *mysql,
|
||||
enum enum_server_command command,
|
||||
const char *header,
|
||||
unsigned long header_length,
|
||||
const char *arg,
|
||||
unsigned long arg_length,
|
||||
my_bool skip_check);
|
||||
MYSQL_DATA *(*read_rows)(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
|
||||
unsigned int fields);
|
||||
MYSQL_RES * (*use_result)(MYSQL *mysql);
|
||||
void (*fetch_lengths)(unsigned long *to,
|
||||
MYSQL_ROW column, unsigned int field_count);
|
||||
void (*flush_use_result)(MYSQL *mysql);
|
||||
#if !defined(MYSQL_SERVER) || defined(EMBEDDED_LIBRARY)
|
||||
MYSQL_FIELD * (*list_fields)(MYSQL *mysql);
|
||||
my_bool (*read_prepare_result)(MYSQL *mysql, MYSQL_STMT *stmt);
|
||||
int (*stmt_execute)(MYSQL_STMT *stmt);
|
||||
int (*read_binary_rows)(MYSQL_STMT *stmt);
|
||||
int (*unbuffered_fetch)(MYSQL *mysql, char **row);
|
||||
void (*free_embedded_thd)(MYSQL *mysql);
|
||||
const char *(*read_statistics)(MYSQL *mysql);
|
||||
my_bool (*next_result)(MYSQL *mysql);
|
||||
int (*read_change_user_result)(MYSQL *mysql, char *buff, const char *passwd);
|
||||
#endif
|
||||
} MYSQL_METHODS;
|
||||
|
||||
|
||||
MYSQL_STMT * STDCALL mysql_stmt_init(MYSQL *mysql);
|
||||
int STDCALL mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query,
|
||||
unsigned long length);
|
||||
int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt);
|
||||
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt);
|
||||
int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind,
|
||||
unsigned int column,
|
||||
unsigned long offset);
|
||||
int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt);
|
||||
unsigned long STDCALL mysql_stmt_param_count(MYSQL_STMT * stmt);
|
||||
my_bool STDCALL mysql_stmt_attr_set(MYSQL_STMT *stmt,
|
||||
enum enum_stmt_attr_type attr_type,
|
||||
const void *attr);
|
||||
my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt,
|
||||
enum enum_stmt_attr_type attr_type,
|
||||
void *attr);
|
||||
my_bool STDCALL mysql_stmt_bind_param(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
|
||||
my_bool STDCALL mysql_stmt_bind_result(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
|
||||
my_bool STDCALL mysql_stmt_close(MYSQL_STMT * stmt);
|
||||
my_bool STDCALL mysql_stmt_reset(MYSQL_STMT * stmt);
|
||||
my_bool STDCALL mysql_stmt_free_result(MYSQL_STMT *stmt);
|
||||
my_bool STDCALL mysql_stmt_send_long_data(MYSQL_STMT *stmt,
|
||||
unsigned int param_number,
|
||||
const char *data,
|
||||
unsigned long length);
|
||||
MYSQL_RES *STDCALL mysql_stmt_result_metadata(MYSQL_STMT *stmt);
|
||||
MYSQL_RES *STDCALL mysql_stmt_param_metadata(MYSQL_STMT *stmt);
|
||||
unsigned int STDCALL mysql_stmt_errno(MYSQL_STMT * stmt);
|
||||
const char *STDCALL mysql_stmt_error(MYSQL_STMT * stmt);
|
||||
const char *STDCALL mysql_stmt_sqlstate(MYSQL_STMT * stmt);
|
||||
MYSQL_ROW_OFFSET STDCALL mysql_stmt_row_seek(MYSQL_STMT *stmt,
|
||||
MYSQL_ROW_OFFSET offset);
|
||||
MYSQL_ROW_OFFSET STDCALL mysql_stmt_row_tell(MYSQL_STMT *stmt);
|
||||
void STDCALL mysql_stmt_data_seek(MYSQL_STMT *stmt, my_ulonglong offset);
|
||||
my_ulonglong STDCALL mysql_stmt_num_rows(MYSQL_STMT *stmt);
|
||||
my_ulonglong STDCALL mysql_stmt_affected_rows(MYSQL_STMT *stmt);
|
||||
my_ulonglong STDCALL mysql_stmt_insert_id(MYSQL_STMT *stmt);
|
||||
unsigned int STDCALL mysql_stmt_field_count(MYSQL_STMT *stmt);
|
||||
|
||||
my_bool STDCALL mysql_commit(MYSQL * mysql);
|
||||
my_bool STDCALL mysql_rollback(MYSQL * mysql);
|
||||
my_bool STDCALL mysql_autocommit(MYSQL * mysql, my_bool auto_mode);
|
||||
my_bool STDCALL mysql_more_results(MYSQL *mysql);
|
||||
int STDCALL mysql_next_result(MYSQL *mysql);
|
||||
void STDCALL mysql_close(MYSQL *sock);
|
||||
|
||||
|
||||
/* status return codes */
|
||||
#define MYSQL_NO_DATA 100
|
||||
#define MYSQL_DATA_TRUNCATED 101
|
||||
|
||||
#define mysql_reload(mysql) mysql_refresh((mysql),REFRESH_GRANT)
|
||||
|
||||
#ifdef USE_OLD_FUNCTIONS
|
||||
MYSQL * STDCALL mysql_connect(MYSQL *mysql, const char *host,
|
||||
const char *user, const char *passwd);
|
||||
int STDCALL mysql_create_db(MYSQL *mysql, const char *DB);
|
||||
int STDCALL mysql_drop_db(MYSQL *mysql, const char *DB);
|
||||
#define mysql_reload(mysql) mysql_refresh((mysql),REFRESH_GRANT)
|
||||
#endif
|
||||
#define HAVE_MYSQL_REAL_CONNECT
|
||||
|
||||
/*
|
||||
The following functions are mainly exported because of mysqlbinlog;
|
||||
They are not for general usage
|
||||
*/
|
||||
|
||||
#define simple_command(mysql, command, arg, length, skip_check) \
|
||||
(*(mysql)->methods->advanced_command)(mysql, command, \
|
||||
NullS, 0, arg, length, skip_check)
|
||||
unsigned long net_safe_read(MYSQL* mysql);
|
||||
|
||||
#ifdef __NETWARE__
|
||||
#pragma pack(pop) /* restore alignment */
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _mysql_h */
|
||||
+444
@@ -0,0 +1,444 @@
|
||||
/* Copyright (C) 2000 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
/*
|
||||
** Common definition between mysql server & client
|
||||
*/
|
||||
|
||||
#ifndef _mysql_com_h
|
||||
#define _mysql_com_h
|
||||
|
||||
#define NAME_LEN 64 /* Field/table name length */
|
||||
#define HOSTNAME_LENGTH 60
|
||||
#define USERNAME_LENGTH 16
|
||||
#define SERVER_VERSION_LENGTH 60
|
||||
#define SQLSTATE_LENGTH 5
|
||||
|
||||
#define LOCAL_HOST "localhost"
|
||||
#define LOCAL_HOST_NAMEDPIPE "."
|
||||
|
||||
|
||||
#if defined(__WIN__) && !defined( _CUSTOMCONFIG_)
|
||||
#define MYSQL_NAMEDPIPE "MySQL"
|
||||
#define MYSQL_SERVICENAME "MySQL"
|
||||
#endif /* __WIN__ */
|
||||
|
||||
/*
|
||||
You should add new commands to the end of this list, otherwise old
|
||||
servers won't be able to handle them as 'unsupported'.
|
||||
*/
|
||||
|
||||
enum enum_server_command
|
||||
{
|
||||
COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST,
|
||||
COM_CREATE_DB, COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS,
|
||||
COM_PROCESS_INFO, COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING,
|
||||
COM_TIME, COM_DELAYED_INSERT, COM_CHANGE_USER, COM_BINLOG_DUMP,
|
||||
COM_TABLE_DUMP, COM_CONNECT_OUT, COM_REGISTER_SLAVE,
|
||||
COM_STMT_PREPARE, COM_STMT_EXECUTE, COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE,
|
||||
COM_STMT_RESET, COM_SET_OPTION, COM_STMT_FETCH,
|
||||
/* don't forget to update const char *command_name[] in sql_parse.cc */
|
||||
|
||||
/* Must be last */
|
||||
COM_END
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
Length of random string sent by server on handshake; this is also length of
|
||||
obfuscated password, recieved from client
|
||||
*/
|
||||
#define SCRAMBLE_LENGTH 20
|
||||
#define SCRAMBLE_LENGTH_323 8
|
||||
/* length of password stored in the db: new passwords are preceeded with '*' */
|
||||
#define SCRAMBLED_PASSWORD_CHAR_LENGTH (SCRAMBLE_LENGTH*2+1)
|
||||
#define SCRAMBLED_PASSWORD_CHAR_LENGTH_323 (SCRAMBLE_LENGTH_323*2)
|
||||
|
||||
|
||||
#define NOT_NULL_FLAG 1 /* Field can't be NULL */
|
||||
#define PRI_KEY_FLAG 2 /* Field is part of a primary key */
|
||||
#define UNIQUE_KEY_FLAG 4 /* Field is part of a unique key */
|
||||
#define MULTIPLE_KEY_FLAG 8 /* Field is part of a key */
|
||||
#define BLOB_FLAG 16 /* Field is a blob */
|
||||
#define UNSIGNED_FLAG 32 /* Field is unsigned */
|
||||
#define ZEROFILL_FLAG 64 /* Field is zerofill */
|
||||
#define BINARY_FLAG 128 /* Field is binary */
|
||||
|
||||
/* The following are only sent to new clients */
|
||||
#define ENUM_FLAG 256 /* field is an enum */
|
||||
#define AUTO_INCREMENT_FLAG 512 /* field is a autoincrement field */
|
||||
#define TIMESTAMP_FLAG 1024 /* Field is a timestamp */
|
||||
#define SET_FLAG 2048 /* field is a set */
|
||||
#define NO_DEFAULT_VALUE_FLAG 4096 /* Field doesn't have default value */
|
||||
#define NUM_FLAG 32768 /* Field is num (for clients) */
|
||||
#define PART_KEY_FLAG 16384 /* Intern; Part of some key */
|
||||
#define GROUP_FLAG 32768 /* Intern: Group field */
|
||||
#define UNIQUE_FLAG 65536 /* Intern: Used by sql_yacc */
|
||||
#define BINCMP_FLAG 131072 /* Intern: Used by sql_yacc */
|
||||
|
||||
#define REFRESH_GRANT 1 /* Refresh grant tables */
|
||||
#define REFRESH_LOG 2 /* Start on new log file */
|
||||
#define REFRESH_TABLES 4 /* close all tables */
|
||||
#define REFRESH_HOSTS 8 /* Flush host cache */
|
||||
#define REFRESH_STATUS 16 /* Flush status variables */
|
||||
#define REFRESH_THREADS 32 /* Flush thread cache */
|
||||
#define REFRESH_SLAVE 64 /* Reset master info and restart slave
|
||||
thread */
|
||||
#define REFRESH_MASTER 128 /* Remove all bin logs in the index
|
||||
and truncate the index */
|
||||
|
||||
/* The following can't be set with mysql_refresh() */
|
||||
#define REFRESH_READ_LOCK 16384 /* Lock tables for read */
|
||||
#define REFRESH_FAST 32768 /* Intern flag */
|
||||
|
||||
/* RESET (remove all queries) from query cache */
|
||||
#define REFRESH_QUERY_CACHE 65536
|
||||
#define REFRESH_QUERY_CACHE_FREE 0x20000L /* pack query cache */
|
||||
#define REFRESH_DES_KEY_FILE 0x40000L
|
||||
#define REFRESH_USER_RESOURCES 0x80000L
|
||||
|
||||
#define CLIENT_LONG_PASSWORD 1 /* new more secure passwords */
|
||||
#define CLIENT_FOUND_ROWS 2 /* Found instead of affected rows */
|
||||
#define CLIENT_LONG_FLAG 4 /* Get all column flags */
|
||||
#define CLIENT_CONNECT_WITH_DB 8 /* One can specify db on connect */
|
||||
#define CLIENT_NO_SCHEMA 16 /* Don't allow database.table.column */
|
||||
#define CLIENT_COMPRESS 32 /* Can use compression protocol */
|
||||
#define CLIENT_ODBC 64 /* Odbc client */
|
||||
#define CLIENT_LOCAL_FILES 128 /* Can use LOAD DATA LOCAL */
|
||||
#define CLIENT_IGNORE_SPACE 256 /* Ignore spaces before '(' */
|
||||
#define CLIENT_PROTOCOL_41 512 /* New 4.1 protocol */
|
||||
#define CLIENT_INTERACTIVE 1024 /* This is an interactive client */
|
||||
#define CLIENT_SSL 2048 /* Switch to SSL after handshake */
|
||||
#define CLIENT_IGNORE_SIGPIPE 4096 /* IGNORE sigpipes */
|
||||
#define CLIENT_TRANSACTIONS 8192 /* Client knows about transactions */
|
||||
#define CLIENT_RESERVED 16384 /* Old flag for 4.1 protocol */
|
||||
#define CLIENT_SECURE_CONNECTION 32768 /* New 4.1 authentication */
|
||||
#define CLIENT_MULTI_STATEMENTS 65536 /* Enable/disable multi-stmt support */
|
||||
#define CLIENT_MULTI_RESULTS 131072 /* Enable/disable multi-results */
|
||||
#define CLIENT_REMEMBER_OPTIONS (((ulong) 1) << 31)
|
||||
|
||||
#define SERVER_STATUS_IN_TRANS 1 /* Transaction has started */
|
||||
#define SERVER_STATUS_AUTOCOMMIT 2 /* Server in auto_commit mode */
|
||||
#define SERVER_STATUS_MORE_RESULTS 4 /* More results on server */
|
||||
#define SERVER_MORE_RESULTS_EXISTS 8 /* Multi query - next query exists */
|
||||
#define SERVER_QUERY_NO_GOOD_INDEX_USED 16
|
||||
#define SERVER_QUERY_NO_INDEX_USED 32
|
||||
/*
|
||||
The server was able to fulfill the clients request and opened a
|
||||
read-only non-scrollable cursor for a query. This flag comes
|
||||
in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands.
|
||||
*/
|
||||
#define SERVER_STATUS_CURSOR_EXISTS 64
|
||||
/*
|
||||
This flag is sent when a read-only cursor is exhausted, in reply to
|
||||
COM_STMT_FETCH command.
|
||||
*/
|
||||
#define SERVER_STATUS_LAST_ROW_SENT 128
|
||||
#define SERVER_STATUS_DB_DROPPED 256 /* A database was dropped */
|
||||
#define SERVER_STATUS_NO_BACKSLASH_ESCAPES 512
|
||||
|
||||
#define MYSQL_ERRMSG_SIZE 512
|
||||
#define NET_READ_TIMEOUT 30 /* Timeout on read */
|
||||
#define NET_WRITE_TIMEOUT 60 /* Timeout on write */
|
||||
#define NET_WAIT_TIMEOUT 8*60*60 /* Wait for new query */
|
||||
|
||||
#define ONLY_KILL_QUERY 1
|
||||
|
||||
struct st_vio; /* Only C */
|
||||
typedef struct st_vio Vio;
|
||||
|
||||
#define MAX_TINYINT_WIDTH 3 /* Max width for a TINY w.o. sign */
|
||||
#define MAX_SMALLINT_WIDTH 5 /* Max width for a SHORT w.o. sign */
|
||||
#define MAX_MEDIUMINT_WIDTH 8 /* Max width for a INT24 w.o. sign */
|
||||
#define MAX_INT_WIDTH 10 /* Max width for a LONG w.o. sign */
|
||||
#define MAX_BIGINT_WIDTH 20 /* Max width for a LONGLONG */
|
||||
#define MAX_CHAR_WIDTH 255 /* Max length for a CHAR colum */
|
||||
#define MAX_BLOB_WIDTH 8192 /* Default width for blob */
|
||||
|
||||
typedef struct st_net {
|
||||
#if !defined(CHECK_EMBEDDED_DIFFERENCES) || !defined(EMBEDDED_LIBRARY)
|
||||
Vio* vio;
|
||||
unsigned char *buff,*buff_end,*write_pos,*read_pos;
|
||||
my_socket fd; /* For Perl DBI/dbd */
|
||||
unsigned long max_packet,max_packet_size;
|
||||
unsigned int pkt_nr,compress_pkt_nr;
|
||||
unsigned int write_timeout, read_timeout, retry_count;
|
||||
int fcntl;
|
||||
my_bool compress;
|
||||
/*
|
||||
The following variable is set if we are doing several queries in one
|
||||
command ( as in LOAD TABLE ... FROM MASTER ),
|
||||
and do not want to confuse the client with OK at the wrong time
|
||||
*/
|
||||
unsigned long remain_in_buf,length, buf_length, where_b;
|
||||
unsigned int *return_status;
|
||||
unsigned char reading_or_writing;
|
||||
char save_char;
|
||||
my_bool no_send_ok; /* For SPs and other things that do multiple stmts */
|
||||
my_bool no_send_eof; /* For SPs' first version read-only cursors */
|
||||
/*
|
||||
Set if OK packet is already sent, and we do not need to send error
|
||||
messages
|
||||
*/
|
||||
my_bool no_send_error;
|
||||
/*
|
||||
Pointer to query object in query cache, do not equal NULL (0) for
|
||||
queries in cache that have not stored its results yet
|
||||
*/
|
||||
#endif
|
||||
char last_error[MYSQL_ERRMSG_SIZE], sqlstate[SQLSTATE_LENGTH+1];
|
||||
unsigned int last_errno;
|
||||
unsigned char error;
|
||||
gptr query_cache_query;
|
||||
my_bool report_error; /* We should report error (we have unreported error) */
|
||||
my_bool return_errno;
|
||||
} NET;
|
||||
|
||||
#define packet_error (~(unsigned long) 0)
|
||||
|
||||
enum enum_field_types { MYSQL_TYPE_DECIMAL, MYSQL_TYPE_TINY,
|
||||
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
|
||||
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
|
||||
MYSQL_TYPE_NULL, MYSQL_TYPE_TIMESTAMP,
|
||||
MYSQL_TYPE_LONGLONG,MYSQL_TYPE_INT24,
|
||||
MYSQL_TYPE_DATE, MYSQL_TYPE_TIME,
|
||||
MYSQL_TYPE_DATETIME, MYSQL_TYPE_YEAR,
|
||||
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
|
||||
MYSQL_TYPE_BIT,
|
||||
MYSQL_TYPE_NEWDECIMAL=246,
|
||||
MYSQL_TYPE_ENUM=247,
|
||||
MYSQL_TYPE_SET=248,
|
||||
MYSQL_TYPE_TINY_BLOB=249,
|
||||
MYSQL_TYPE_MEDIUM_BLOB=250,
|
||||
MYSQL_TYPE_LONG_BLOB=251,
|
||||
MYSQL_TYPE_BLOB=252,
|
||||
MYSQL_TYPE_VAR_STRING=253,
|
||||
MYSQL_TYPE_STRING=254,
|
||||
MYSQL_TYPE_GEOMETRY=255
|
||||
|
||||
};
|
||||
|
||||
/* For backward compatibility */
|
||||
#define CLIENT_MULTI_QUERIES CLIENT_MULTI_STATEMENTS
|
||||
#define FIELD_TYPE_DECIMAL MYSQL_TYPE_DECIMAL
|
||||
#define FIELD_TYPE_NEWDECIMAL MYSQL_TYPE_NEWDECIMAL
|
||||
#define FIELD_TYPE_TINY MYSQL_TYPE_TINY
|
||||
#define FIELD_TYPE_SHORT MYSQL_TYPE_SHORT
|
||||
#define FIELD_TYPE_LONG MYSQL_TYPE_LONG
|
||||
#define FIELD_TYPE_FLOAT MYSQL_TYPE_FLOAT
|
||||
#define FIELD_TYPE_DOUBLE MYSQL_TYPE_DOUBLE
|
||||
#define FIELD_TYPE_NULL MYSQL_TYPE_NULL
|
||||
#define FIELD_TYPE_TIMESTAMP MYSQL_TYPE_TIMESTAMP
|
||||
#define FIELD_TYPE_LONGLONG MYSQL_TYPE_LONGLONG
|
||||
#define FIELD_TYPE_INT24 MYSQL_TYPE_INT24
|
||||
#define FIELD_TYPE_DATE MYSQL_TYPE_DATE
|
||||
#define FIELD_TYPE_TIME MYSQL_TYPE_TIME
|
||||
#define FIELD_TYPE_DATETIME MYSQL_TYPE_DATETIME
|
||||
#define FIELD_TYPE_YEAR MYSQL_TYPE_YEAR
|
||||
#define FIELD_TYPE_NEWDATE MYSQL_TYPE_NEWDATE
|
||||
#define FIELD_TYPE_ENUM MYSQL_TYPE_ENUM
|
||||
#define FIELD_TYPE_SET MYSQL_TYPE_SET
|
||||
#define FIELD_TYPE_TINY_BLOB MYSQL_TYPE_TINY_BLOB
|
||||
#define FIELD_TYPE_MEDIUM_BLOB MYSQL_TYPE_MEDIUM_BLOB
|
||||
#define FIELD_TYPE_LONG_BLOB MYSQL_TYPE_LONG_BLOB
|
||||
#define FIELD_TYPE_BLOB MYSQL_TYPE_BLOB
|
||||
#define FIELD_TYPE_VAR_STRING MYSQL_TYPE_VAR_STRING
|
||||
#define FIELD_TYPE_STRING MYSQL_TYPE_STRING
|
||||
#define FIELD_TYPE_CHAR MYSQL_TYPE_TINY
|
||||
#define FIELD_TYPE_INTERVAL MYSQL_TYPE_ENUM
|
||||
#define FIELD_TYPE_GEOMETRY MYSQL_TYPE_GEOMETRY
|
||||
#define FIELD_TYPE_BIT MYSQL_TYPE_BIT
|
||||
|
||||
|
||||
/* Shutdown/kill enums and constants */
|
||||
|
||||
/* Bits for THD::killable. */
|
||||
#define MYSQL_SHUTDOWN_KILLABLE_CONNECT (unsigned char)(1 << 0)
|
||||
#define MYSQL_SHUTDOWN_KILLABLE_TRANS (unsigned char)(1 << 1)
|
||||
#define MYSQL_SHUTDOWN_KILLABLE_LOCK_TABLE (unsigned char)(1 << 2)
|
||||
#define MYSQL_SHUTDOWN_KILLABLE_UPDATE (unsigned char)(1 << 3)
|
||||
|
||||
enum mysql_enum_shutdown_level {
|
||||
/*
|
||||
We want levels to be in growing order of hardness (because we use number
|
||||
comparisons). Note that DEFAULT does not respect the growing property, but
|
||||
it's ok.
|
||||
*/
|
||||
SHUTDOWN_DEFAULT = 0,
|
||||
/* wait for existing connections to finish */
|
||||
SHUTDOWN_WAIT_CONNECTIONS= MYSQL_SHUTDOWN_KILLABLE_CONNECT,
|
||||
/* wait for existing trans to finish */
|
||||
SHUTDOWN_WAIT_TRANSACTIONS= MYSQL_SHUTDOWN_KILLABLE_TRANS,
|
||||
/* wait for existing updates to finish (=> no partial MyISAM update) */
|
||||
SHUTDOWN_WAIT_UPDATES= MYSQL_SHUTDOWN_KILLABLE_UPDATE,
|
||||
/* flush InnoDB buffers and other storage engines' buffers*/
|
||||
SHUTDOWN_WAIT_ALL_BUFFERS= (MYSQL_SHUTDOWN_KILLABLE_UPDATE << 1),
|
||||
/* don't flush InnoDB buffers, flush other storage engines' buffers*/
|
||||
SHUTDOWN_WAIT_CRITICAL_BUFFERS= (MYSQL_SHUTDOWN_KILLABLE_UPDATE << 1) + 1,
|
||||
/* Now the 2 levels of the KILL command */
|
||||
#if MYSQL_VERSION_ID >= 50000
|
||||
KILL_QUERY= 254,
|
||||
#endif
|
||||
KILL_CONNECTION= 255
|
||||
};
|
||||
|
||||
|
||||
enum enum_cursor_type
|
||||
{
|
||||
CURSOR_TYPE_NO_CURSOR= 0,
|
||||
CURSOR_TYPE_READ_ONLY= 1,
|
||||
CURSOR_TYPE_FOR_UPDATE= 2,
|
||||
CURSOR_TYPE_SCROLLABLE= 4
|
||||
};
|
||||
|
||||
|
||||
/* options for mysql_set_option */
|
||||
enum enum_mysql_set_option
|
||||
{
|
||||
MYSQL_OPTION_MULTI_STATEMENTS_ON,
|
||||
MYSQL_OPTION_MULTI_STATEMENTS_OFF
|
||||
};
|
||||
|
||||
#define net_new_transaction(net) ((net)->pkt_nr=0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
my_bool my_net_init(NET *net, Vio* vio);
|
||||
void my_net_local_init(NET *net);
|
||||
void net_end(NET *net);
|
||||
void net_clear(NET *net);
|
||||
my_bool net_realloc(NET *net, unsigned long length);
|
||||
my_bool net_flush(NET *net);
|
||||
my_bool my_net_write(NET *net,const char *packet,unsigned long len);
|
||||
my_bool net_write_command(NET *net,unsigned char command,
|
||||
const char *header, unsigned long head_len,
|
||||
const char *packet, unsigned long len);
|
||||
int net_real_write(NET *net,const char *packet,unsigned long len);
|
||||
unsigned long my_net_read(NET *net);
|
||||
|
||||
/*
|
||||
The following function is not meant for normal usage
|
||||
Currently it's used internally by manager.c
|
||||
*/
|
||||
struct sockaddr;
|
||||
int my_connect(my_socket s, const struct sockaddr *name, unsigned int namelen,
|
||||
unsigned int timeout);
|
||||
|
||||
struct rand_struct {
|
||||
unsigned long seed1,seed2,max_value;
|
||||
double max_value_dbl;
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* The following is for user defined functions */
|
||||
|
||||
enum Item_result {STRING_RESULT=0, REAL_RESULT, INT_RESULT, ROW_RESULT,
|
||||
DECIMAL_RESULT};
|
||||
|
||||
typedef struct st_udf_args
|
||||
{
|
||||
unsigned int arg_count; /* Number of arguments */
|
||||
enum Item_result *arg_type; /* Pointer to item_results */
|
||||
char **args; /* Pointer to argument */
|
||||
unsigned long *lengths; /* Length of string arguments */
|
||||
char *maybe_null; /* Set to 1 for all maybe_null args */
|
||||
char **attributes; /* Pointer to attribute name */
|
||||
unsigned long *attribute_lengths; /* Length of attribute arguments */
|
||||
} UDF_ARGS;
|
||||
|
||||
/* This holds information about the result */
|
||||
|
||||
typedef struct st_udf_init
|
||||
{
|
||||
my_bool maybe_null; /* 1 if function can return NULL */
|
||||
unsigned int decimals; /* for real functions */
|
||||
unsigned long max_length; /* For string functions */
|
||||
char *ptr; /* free pointer for function data */
|
||||
my_bool const_item; /* 0 if result is independent of arguments */
|
||||
} UDF_INIT;
|
||||
|
||||
/* Constants when using compression */
|
||||
#define NET_HEADER_SIZE 4 /* standard header size */
|
||||
#define COMP_HEADER_SIZE 3 /* compression header extra size */
|
||||
|
||||
/* Prototypes to password functions */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
These functions are used for authentication by client and server and
|
||||
implemented in sql/password.c
|
||||
*/
|
||||
|
||||
void randominit(struct rand_struct *, unsigned long seed1,
|
||||
unsigned long seed2);
|
||||
double my_rnd(struct rand_struct *);
|
||||
void create_random_string(char *to, unsigned int length, struct rand_struct *rand_st);
|
||||
|
||||
void hash_password(unsigned long *to, const char *password, unsigned int password_len);
|
||||
void make_scrambled_password_323(char *to, const char *password);
|
||||
void scramble_323(char *to, const char *message, const char *password);
|
||||
my_bool check_scramble_323(const char *, const char *message,
|
||||
unsigned long *salt);
|
||||
void get_salt_from_password_323(unsigned long *res, const char *password);
|
||||
void make_password_from_salt_323(char *to, const unsigned long *salt);
|
||||
|
||||
void make_scrambled_password(char *to, const char *password);
|
||||
void scramble(char *to, const char *message, const char *password);
|
||||
my_bool check_scramble(const char *reply, const char *message,
|
||||
const unsigned char *hash_stage2);
|
||||
void get_salt_from_password(unsigned char *res, const char *password);
|
||||
void make_password_from_salt(char *to, const unsigned char *hash_stage2);
|
||||
char *octet2hex(char *to, const char *str, unsigned int len);
|
||||
|
||||
/* end of password.c */
|
||||
|
||||
char *get_tty_password(char *opt_message);
|
||||
const char *mysql_errno_to_sqlstate(unsigned int mysql_errno);
|
||||
|
||||
/* Some other useful functions */
|
||||
|
||||
my_bool my_init(void);
|
||||
extern int modify_defaults_file(const char *file_location, const char *option,
|
||||
const char *option_value,
|
||||
const char *section_name, int remove_option);
|
||||
int load_defaults(const char *conf_file, const char **groups,
|
||||
int *argc, char ***argv);
|
||||
my_bool my_thread_init(void);
|
||||
void my_thread_end(void);
|
||||
|
||||
#ifdef _global_h
|
||||
ulong STDCALL net_field_length(uchar **packet);
|
||||
my_ulonglong net_field_length_ll(uchar **packet);
|
||||
char *net_store_length(char *pkg, ulonglong length);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#define NULL_LENGTH ((unsigned long) ~0) /* For net_store_length */
|
||||
#define MYSQL_STMT_HEADER 4
|
||||
#define MYSQL_LONG_DATA_HEADER 6
|
||||
|
||||
#endif
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
/* Copyright (C) 2000 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
/* Defines that are unique to the embedded version of MySQL */
|
||||
|
||||
#ifdef EMBEDDED_LIBRARY
|
||||
|
||||
/* Things we don't need in the embedded version of MySQL */
|
||||
/* TODO HF add #undef HAVE_VIO if we don't want client in embedded library */
|
||||
|
||||
#undef HAVE_PSTACK /* No stacktrace */
|
||||
#undef HAVE_DLOPEN /* No udf functions */
|
||||
#undef HAVE_OPENSSL
|
||||
#undef HAVE_SMEM /* No shared memory */
|
||||
#undef HAVE_NDBCLUSTER_DB /* No NDB cluster */
|
||||
|
||||
#define DONT_USE_RAID
|
||||
|
||||
#endif /* EMBEDDED_LIBRARY */
|
||||
+56
@@ -0,0 +1,56 @@
|
||||
/* Copyright (C) 2004 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#ifndef _mysql_time_h_
|
||||
#define _mysql_time_h_
|
||||
|
||||
/*
|
||||
Time declarations shared between the server and client API:
|
||||
you should not add anything to this header unless it's used
|
||||
(and hence should be visible) in mysql.h.
|
||||
If you're looking for a place to add new time-related declaration,
|
||||
it's most likely my_time.h. See also "C API Handling of Date
|
||||
and Time Values" chapter in documentation.
|
||||
*/
|
||||
|
||||
enum enum_mysql_timestamp_type
|
||||
{
|
||||
MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
|
||||
MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
Structure which is used to represent datetime values inside MySQL.
|
||||
|
||||
We assume that values in this structure are normalized, i.e. year <= 9999,
|
||||
month <= 12, day <= 31, hour <= 23, hour <= 59, hour <= 59. Many functions
|
||||
in server such as my_system_gmt_sec() or make_time() family of functions
|
||||
rely on this (actually now usage of make_*() family relies on a bit weaker
|
||||
restriction). Also functions that produce MYSQL_TIME as result ensure this.
|
||||
There is one exception to this rule though if this structure holds time
|
||||
value (time_type == MYSQL_TIMESTAMP_TIME) days and hour member can hold
|
||||
bigger values.
|
||||
*/
|
||||
typedef struct st_mysql_time
|
||||
{
|
||||
unsigned int year, month, day, hour, minute, second;
|
||||
unsigned long second_part;
|
||||
my_bool neg;
|
||||
enum enum_mysql_timestamp_type time_type;
|
||||
} MYSQL_TIME;
|
||||
|
||||
#endif /* _mysql_time_h_ */
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
/* Copyright Abandoned 1996, 1999, 2001 MySQL AB
|
||||
This file is public domain and comes with NO WARRANTY of any kind */
|
||||
|
||||
/* Version numbers for protocol & mysqld */
|
||||
|
||||
#ifndef _mysql_version_h
|
||||
#define _mysql_version_h
|
||||
#ifdef _CUSTOMCONFIG_
|
||||
#include <custom_conf.h>
|
||||
#else
|
||||
#define PROTOCOL_VERSION 10
|
||||
#define MYSQL_SERVER_VERSION "5.0.15"
|
||||
#define MYSQL_BASE_VERSION "mysqld-5.0"
|
||||
#define MYSQL_SERVER_SUFFIX_DEF ""
|
||||
#define FRM_VER 6
|
||||
#define MYSQL_VERSION_ID 50015
|
||||
#define MYSQL_PORT 3306
|
||||
#define MYSQL_UNIX_ADDR "/tmp/mysql.sock"
|
||||
#define MYSQL_CONFIG_NAME "my"
|
||||
#define MYSQL_COMPILATION_COMMENT "Official MySQL binary"
|
||||
|
||||
/* mysqld compile time options */
|
||||
#endif /* _CUSTOMCONFIG_ */
|
||||
|
||||
#ifndef LICENSE
|
||||
#define LICENSE GPL
|
||||
#endif /* LICENSE */
|
||||
|
||||
#endif /* _mysql_version_h */
|
||||
+456
@@ -0,0 +1,456 @@
|
||||
/* Autogenerated file, please don't edit */
|
||||
|
||||
{ "ER_HASHCHK", 1000 },
|
||||
{ "ER_NISAMCHK", 1001 },
|
||||
{ "ER_NO", 1002 },
|
||||
{ "ER_YES", 1003 },
|
||||
{ "ER_CANT_CREATE_FILE", 1004 },
|
||||
{ "ER_CANT_CREATE_TABLE", 1005 },
|
||||
{ "ER_CANT_CREATE_DB", 1006 },
|
||||
{ "ER_DB_CREATE_EXISTS", 1007 },
|
||||
{ "ER_DB_DROP_EXISTS", 1008 },
|
||||
{ "ER_DB_DROP_DELETE", 1009 },
|
||||
{ "ER_DB_DROP_RMDIR", 1010 },
|
||||
{ "ER_CANT_DELETE_FILE", 1011 },
|
||||
{ "ER_CANT_FIND_SYSTEM_REC", 1012 },
|
||||
{ "ER_CANT_GET_STAT", 1013 },
|
||||
{ "ER_CANT_GET_WD", 1014 },
|
||||
{ "ER_CANT_LOCK", 1015 },
|
||||
{ "ER_CANT_OPEN_FILE", 1016 },
|
||||
{ "ER_FILE_NOT_FOUND", 1017 },
|
||||
{ "ER_CANT_READ_DIR", 1018 },
|
||||
{ "ER_CANT_SET_WD", 1019 },
|
||||
{ "ER_CHECKREAD", 1020 },
|
||||
{ "ER_DISK_FULL", 1021 },
|
||||
{ "ER_DUP_KEY", 1022 },
|
||||
{ "ER_ERROR_ON_CLOSE", 1023 },
|
||||
{ "ER_ERROR_ON_READ", 1024 },
|
||||
{ "ER_ERROR_ON_RENAME", 1025 },
|
||||
{ "ER_ERROR_ON_WRITE", 1026 },
|
||||
{ "ER_FILE_USED", 1027 },
|
||||
{ "ER_FILSORT_ABORT", 1028 },
|
||||
{ "ER_FORM_NOT_FOUND", 1029 },
|
||||
{ "ER_GET_ERRNO", 1030 },
|
||||
{ "ER_ILLEGAL_HA", 1031 },
|
||||
{ "ER_KEY_NOT_FOUND", 1032 },
|
||||
{ "ER_NOT_FORM_FILE", 1033 },
|
||||
{ "ER_NOT_KEYFILE", 1034 },
|
||||
{ "ER_OLD_KEYFILE", 1035 },
|
||||
{ "ER_OPEN_AS_READONLY", 1036 },
|
||||
{ "ER_OUTOFMEMORY", 1037 },
|
||||
{ "ER_OUT_OF_SORTMEMORY", 1038 },
|
||||
{ "ER_UNEXPECTED_EOF", 1039 },
|
||||
{ "ER_CON_COUNT_ERROR", 1040 },
|
||||
{ "ER_OUT_OF_RESOURCES", 1041 },
|
||||
{ "ER_BAD_HOST_ERROR", 1042 },
|
||||
{ "ER_HANDSHAKE_ERROR", 1043 },
|
||||
{ "ER_DBACCESS_DENIED_ERROR", 1044 },
|
||||
{ "ER_ACCESS_DENIED_ERROR", 1045 },
|
||||
{ "ER_NO_DB_ERROR", 1046 },
|
||||
{ "ER_UNKNOWN_COM_ERROR", 1047 },
|
||||
{ "ER_BAD_NULL_ERROR", 1048 },
|
||||
{ "ER_BAD_DB_ERROR", 1049 },
|
||||
{ "ER_TABLE_EXISTS_ERROR", 1050 },
|
||||
{ "ER_BAD_TABLE_ERROR", 1051 },
|
||||
{ "ER_NON_UNIQ_ERROR", 1052 },
|
||||
{ "ER_SERVER_SHUTDOWN", 1053 },
|
||||
{ "ER_BAD_FIELD_ERROR", 1054 },
|
||||
{ "ER_WRONG_FIELD_WITH_GROUP", 1055 },
|
||||
{ "ER_WRONG_GROUP_FIELD", 1056 },
|
||||
{ "ER_WRONG_SUM_SELECT", 1057 },
|
||||
{ "ER_WRONG_VALUE_COUNT", 1058 },
|
||||
{ "ER_TOO_LONG_IDENT", 1059 },
|
||||
{ "ER_DUP_FIELDNAME", 1060 },
|
||||
{ "ER_DUP_KEYNAME", 1061 },
|
||||
{ "ER_DUP_ENTRY", 1062 },
|
||||
{ "ER_WRONG_FIELD_SPEC", 1063 },
|
||||
{ "ER_PARSE_ERROR", 1064 },
|
||||
{ "ER_EMPTY_QUERY", 1065 },
|
||||
{ "ER_NONUNIQ_TABLE", 1066 },
|
||||
{ "ER_INVALID_DEFAULT", 1067 },
|
||||
{ "ER_MULTIPLE_PRI_KEY", 1068 },
|
||||
{ "ER_TOO_MANY_KEYS", 1069 },
|
||||
{ "ER_TOO_MANY_KEY_PARTS", 1070 },
|
||||
{ "ER_TOO_LONG_KEY", 1071 },
|
||||
{ "ER_KEY_COLUMN_DOES_NOT_EXITS", 1072 },
|
||||
{ "ER_BLOB_USED_AS_KEY", 1073 },
|
||||
{ "ER_TOO_BIG_FIELDLENGTH", 1074 },
|
||||
{ "ER_WRONG_AUTO_KEY", 1075 },
|
||||
{ "ER_READY", 1076 },
|
||||
{ "ER_NORMAL_SHUTDOWN", 1077 },
|
||||
{ "ER_GOT_SIGNAL", 1078 },
|
||||
{ "ER_SHUTDOWN_COMPLETE", 1079 },
|
||||
{ "ER_FORCING_CLOSE", 1080 },
|
||||
{ "ER_IPSOCK_ERROR", 1081 },
|
||||
{ "ER_NO_SUCH_INDEX", 1082 },
|
||||
{ "ER_WRONG_FIELD_TERMINATORS", 1083 },
|
||||
{ "ER_BLOBS_AND_NO_TERMINATED", 1084 },
|
||||
{ "ER_TEXTFILE_NOT_READABLE", 1085 },
|
||||
{ "ER_FILE_EXISTS_ERROR", 1086 },
|
||||
{ "ER_LOAD_INFO", 1087 },
|
||||
{ "ER_ALTER_INFO", 1088 },
|
||||
{ "ER_WRONG_SUB_KEY", 1089 },
|
||||
{ "ER_CANT_REMOVE_ALL_FIELDS", 1090 },
|
||||
{ "ER_CANT_DROP_FIELD_OR_KEY", 1091 },
|
||||
{ "ER_INSERT_INFO", 1092 },
|
||||
{ "ER_UPDATE_TABLE_USED", 1093 },
|
||||
{ "ER_NO_SUCH_THREAD", 1094 },
|
||||
{ "ER_KILL_DENIED_ERROR", 1095 },
|
||||
{ "ER_NO_TABLES_USED", 1096 },
|
||||
{ "ER_TOO_BIG_SET", 1097 },
|
||||
{ "ER_NO_UNIQUE_LOGFILE", 1098 },
|
||||
{ "ER_TABLE_NOT_LOCKED_FOR_WRITE", 1099 },
|
||||
{ "ER_TABLE_NOT_LOCKED", 1100 },
|
||||
{ "ER_BLOB_CANT_HAVE_DEFAULT", 1101 },
|
||||
{ "ER_WRONG_DB_NAME", 1102 },
|
||||
{ "ER_WRONG_TABLE_NAME", 1103 },
|
||||
{ "ER_TOO_BIG_SELECT", 1104 },
|
||||
{ "ER_UNKNOWN_ERROR", 1105 },
|
||||
{ "ER_UNKNOWN_PROCEDURE", 1106 },
|
||||
{ "ER_WRONG_PARAMCOUNT_TO_PROCEDURE", 1107 },
|
||||
{ "ER_WRONG_PARAMETERS_TO_PROCEDURE", 1108 },
|
||||
{ "ER_UNKNOWN_TABLE", 1109 },
|
||||
{ "ER_FIELD_SPECIFIED_TWICE", 1110 },
|
||||
{ "ER_INVALID_GROUP_FUNC_USE", 1111 },
|
||||
{ "ER_UNSUPPORTED_EXTENSION", 1112 },
|
||||
{ "ER_TABLE_MUST_HAVE_COLUMNS", 1113 },
|
||||
{ "ER_RECORD_FILE_FULL", 1114 },
|
||||
{ "ER_UNKNOWN_CHARACTER_SET", 1115 },
|
||||
{ "ER_TOO_MANY_TABLES", 1116 },
|
||||
{ "ER_TOO_MANY_FIELDS", 1117 },
|
||||
{ "ER_TOO_BIG_ROWSIZE", 1118 },
|
||||
{ "ER_STACK_OVERRUN", 1119 },
|
||||
{ "ER_WRONG_OUTER_JOIN", 1120 },
|
||||
{ "ER_NULL_COLUMN_IN_INDEX", 1121 },
|
||||
{ "ER_CANT_FIND_UDF", 1122 },
|
||||
{ "ER_CANT_INITIALIZE_UDF", 1123 },
|
||||
{ "ER_UDF_NO_PATHS", 1124 },
|
||||
{ "ER_UDF_EXISTS", 1125 },
|
||||
{ "ER_CANT_OPEN_LIBRARY", 1126 },
|
||||
{ "ER_CANT_FIND_DL_ENTRY", 1127 },
|
||||
{ "ER_FUNCTION_NOT_DEFINED", 1128 },
|
||||
{ "ER_HOST_IS_BLOCKED", 1129 },
|
||||
{ "ER_HOST_NOT_PRIVILEGED", 1130 },
|
||||
{ "ER_PASSWORD_ANONYMOUS_USER", 1131 },
|
||||
{ "ER_PASSWORD_NOT_ALLOWED", 1132 },
|
||||
{ "ER_PASSWORD_NO_MATCH", 1133 },
|
||||
{ "ER_UPDATE_INFO", 1134 },
|
||||
{ "ER_CANT_CREATE_THREAD", 1135 },
|
||||
{ "ER_WRONG_VALUE_COUNT_ON_ROW", 1136 },
|
||||
{ "ER_CANT_REOPEN_TABLE", 1137 },
|
||||
{ "ER_INVALID_USE_OF_NULL", 1138 },
|
||||
{ "ER_REGEXP_ERROR", 1139 },
|
||||
{ "ER_MIX_OF_GROUP_FUNC_AND_FIELDS", 1140 },
|
||||
{ "ER_NONEXISTING_GRANT", 1141 },
|
||||
{ "ER_TABLEACCESS_DENIED_ERROR", 1142 },
|
||||
{ "ER_COLUMNACCESS_DENIED_ERROR", 1143 },
|
||||
{ "ER_ILLEGAL_GRANT_FOR_TABLE", 1144 },
|
||||
{ "ER_GRANT_WRONG_HOST_OR_USER", 1145 },
|
||||
{ "ER_NO_SUCH_TABLE", 1146 },
|
||||
{ "ER_NONEXISTING_TABLE_GRANT", 1147 },
|
||||
{ "ER_NOT_ALLOWED_COMMAND", 1148 },
|
||||
{ "ER_SYNTAX_ERROR", 1149 },
|
||||
{ "ER_DELAYED_CANT_CHANGE_LOCK", 1150 },
|
||||
{ "ER_TOO_MANY_DELAYED_THREADS", 1151 },
|
||||
{ "ER_ABORTING_CONNECTION", 1152 },
|
||||
{ "ER_NET_PACKET_TOO_LARGE", 1153 },
|
||||
{ "ER_NET_READ_ERROR_FROM_PIPE", 1154 },
|
||||
{ "ER_NET_FCNTL_ERROR", 1155 },
|
||||
{ "ER_NET_PACKETS_OUT_OF_ORDER", 1156 },
|
||||
{ "ER_NET_UNCOMPRESS_ERROR", 1157 },
|
||||
{ "ER_NET_READ_ERROR", 1158 },
|
||||
{ "ER_NET_READ_INTERRUPTED", 1159 },
|
||||
{ "ER_NET_ERROR_ON_WRITE", 1160 },
|
||||
{ "ER_NET_WRITE_INTERRUPTED", 1161 },
|
||||
{ "ER_TOO_LONG_STRING", 1162 },
|
||||
{ "ER_TABLE_CANT_HANDLE_BLOB", 1163 },
|
||||
{ "ER_TABLE_CANT_HANDLE_AUTO_INCREMENT", 1164 },
|
||||
{ "ER_DELAYED_INSERT_TABLE_LOCKED", 1165 },
|
||||
{ "ER_WRONG_COLUMN_NAME", 1166 },
|
||||
{ "ER_WRONG_KEY_COLUMN", 1167 },
|
||||
{ "ER_WRONG_MRG_TABLE", 1168 },
|
||||
{ "ER_DUP_UNIQUE", 1169 },
|
||||
{ "ER_BLOB_KEY_WITHOUT_LENGTH", 1170 },
|
||||
{ "ER_PRIMARY_CANT_HAVE_NULL", 1171 },
|
||||
{ "ER_TOO_MANY_ROWS", 1172 },
|
||||
{ "ER_REQUIRES_PRIMARY_KEY", 1173 },
|
||||
{ "ER_NO_RAID_COMPILED", 1174 },
|
||||
{ "ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE", 1175 },
|
||||
{ "ER_KEY_DOES_NOT_EXITS", 1176 },
|
||||
{ "ER_CHECK_NO_SUCH_TABLE", 1177 },
|
||||
{ "ER_CHECK_NOT_IMPLEMENTED", 1178 },
|
||||
{ "ER_CANT_DO_THIS_DURING_AN_TRANSACTION", 1179 },
|
||||
{ "ER_ERROR_DURING_COMMIT", 1180 },
|
||||
{ "ER_ERROR_DURING_ROLLBACK", 1181 },
|
||||
{ "ER_ERROR_DURING_FLUSH_LOGS", 1182 },
|
||||
{ "ER_ERROR_DURING_CHECKPOINT", 1183 },
|
||||
{ "ER_NEW_ABORTING_CONNECTION", 1184 },
|
||||
{ "ER_DUMP_NOT_IMPLEMENTED", 1185 },
|
||||
{ "ER_FLUSH_MASTER_BINLOG_CLOSED", 1186 },
|
||||
{ "ER_INDEX_REBUILD", 1187 },
|
||||
{ "ER_MASTER", 1188 },
|
||||
{ "ER_MASTER_NET_READ", 1189 },
|
||||
{ "ER_MASTER_NET_WRITE", 1190 },
|
||||
{ "ER_FT_MATCHING_KEY_NOT_FOUND", 1191 },
|
||||
{ "ER_LOCK_OR_ACTIVE_TRANSACTION", 1192 },
|
||||
{ "ER_UNKNOWN_SYSTEM_VARIABLE", 1193 },
|
||||
{ "ER_CRASHED_ON_USAGE", 1194 },
|
||||
{ "ER_CRASHED_ON_REPAIR", 1195 },
|
||||
{ "ER_WARNING_NOT_COMPLETE_ROLLBACK", 1196 },
|
||||
{ "ER_TRANS_CACHE_FULL", 1197 },
|
||||
{ "ER_SLAVE_MUST_STOP", 1198 },
|
||||
{ "ER_SLAVE_NOT_RUNNING", 1199 },
|
||||
{ "ER_BAD_SLAVE", 1200 },
|
||||
{ "ER_MASTER_INFO", 1201 },
|
||||
{ "ER_SLAVE_THREAD", 1202 },
|
||||
{ "ER_TOO_MANY_USER_CONNECTIONS", 1203 },
|
||||
{ "ER_SET_CONSTANTS_ONLY", 1204 },
|
||||
{ "ER_LOCK_WAIT_TIMEOUT", 1205 },
|
||||
{ "ER_LOCK_TABLE_FULL", 1206 },
|
||||
{ "ER_READ_ONLY_TRANSACTION", 1207 },
|
||||
{ "ER_DROP_DB_WITH_READ_LOCK", 1208 },
|
||||
{ "ER_CREATE_DB_WITH_READ_LOCK", 1209 },
|
||||
{ "ER_WRONG_ARGUMENTS", 1210 },
|
||||
{ "ER_NO_PERMISSION_TO_CREATE_USER", 1211 },
|
||||
{ "ER_UNION_TABLES_IN_DIFFERENT_DIR", 1212 },
|
||||
{ "ER_LOCK_DEADLOCK", 1213 },
|
||||
{ "ER_TABLE_CANT_HANDLE_FT", 1214 },
|
||||
{ "ER_CANNOT_ADD_FOREIGN", 1215 },
|
||||
{ "ER_NO_REFERENCED_ROW", 1216 },
|
||||
{ "ER_ROW_IS_REFERENCED", 1217 },
|
||||
{ "ER_CONNECT_TO_MASTER", 1218 },
|
||||
{ "ER_QUERY_ON_MASTER", 1219 },
|
||||
{ "ER_ERROR_WHEN_EXECUTING_COMMAND", 1220 },
|
||||
{ "ER_WRONG_USAGE", 1221 },
|
||||
{ "ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT", 1222 },
|
||||
{ "ER_CANT_UPDATE_WITH_READLOCK", 1223 },
|
||||
{ "ER_MIXING_NOT_ALLOWED", 1224 },
|
||||
{ "ER_DUP_ARGUMENT", 1225 },
|
||||
{ "ER_USER_LIMIT_REACHED", 1226 },
|
||||
{ "ER_SPECIFIC_ACCESS_DENIED_ERROR", 1227 },
|
||||
{ "ER_LOCAL_VARIABLE", 1228 },
|
||||
{ "ER_GLOBAL_VARIABLE", 1229 },
|
||||
{ "ER_NO_DEFAULT", 1230 },
|
||||
{ "ER_WRONG_VALUE_FOR_VAR", 1231 },
|
||||
{ "ER_WRONG_TYPE_FOR_VAR", 1232 },
|
||||
{ "ER_VAR_CANT_BE_READ", 1233 },
|
||||
{ "ER_CANT_USE_OPTION_HERE", 1234 },
|
||||
{ "ER_NOT_SUPPORTED_YET", 1235 },
|
||||
{ "ER_MASTER_FATAL_ERROR_READING_BINLOG", 1236 },
|
||||
{ "ER_SLAVE_IGNORED_TABLE", 1237 },
|
||||
{ "ER_INCORRECT_GLOBAL_LOCAL_VAR", 1238 },
|
||||
{ "ER_WRONG_FK_DEF", 1239 },
|
||||
{ "ER_KEY_REF_DO_NOT_MATCH_TABLE_REF", 1240 },
|
||||
{ "ER_OPERAND_COLUMNS", 1241 },
|
||||
{ "ER_SUBQUERY_NO_1_ROW", 1242 },
|
||||
{ "ER_UNKNOWN_STMT_HANDLER", 1243 },
|
||||
{ "ER_CORRUPT_HELP_DB", 1244 },
|
||||
{ "ER_CYCLIC_REFERENCE", 1245 },
|
||||
{ "ER_AUTO_CONVERT", 1246 },
|
||||
{ "ER_ILLEGAL_REFERENCE", 1247 },
|
||||
{ "ER_DERIVED_MUST_HAVE_ALIAS", 1248 },
|
||||
{ "ER_SELECT_REDUCED", 1249 },
|
||||
{ "ER_TABLENAME_NOT_ALLOWED_HERE", 1250 },
|
||||
{ "ER_NOT_SUPPORTED_AUTH_MODE", 1251 },
|
||||
{ "ER_SPATIAL_CANT_HAVE_NULL", 1252 },
|
||||
{ "ER_COLLATION_CHARSET_MISMATCH", 1253 },
|
||||
{ "ER_SLAVE_WAS_RUNNING", 1254 },
|
||||
{ "ER_SLAVE_WAS_NOT_RUNNING", 1255 },
|
||||
{ "ER_TOO_BIG_FOR_UNCOMPRESS", 1256 },
|
||||
{ "ER_ZLIB_Z_MEM_ERROR", 1257 },
|
||||
{ "ER_ZLIB_Z_BUF_ERROR", 1258 },
|
||||
{ "ER_ZLIB_Z_DATA_ERROR", 1259 },
|
||||
{ "ER_CUT_VALUE_GROUP_CONCAT", 1260 },
|
||||
{ "ER_WARN_TOO_FEW_RECORDS", 1261 },
|
||||
{ "ER_WARN_TOO_MANY_RECORDS", 1262 },
|
||||
{ "ER_WARN_NULL_TO_NOTNULL", 1263 },
|
||||
{ "ER_WARN_DATA_OUT_OF_RANGE", 1264 },
|
||||
{ "WARN_DATA_TRUNCATED", 1265 },
|
||||
{ "ER_WARN_USING_OTHER_HANDLER", 1266 },
|
||||
{ "ER_CANT_AGGREGATE_2COLLATIONS", 1267 },
|
||||
{ "ER_DROP_USER", 1268 },
|
||||
{ "ER_REVOKE_GRANTS", 1269 },
|
||||
{ "ER_CANT_AGGREGATE_3COLLATIONS", 1270 },
|
||||
{ "ER_CANT_AGGREGATE_NCOLLATIONS", 1271 },
|
||||
{ "ER_VARIABLE_IS_NOT_STRUCT", 1272 },
|
||||
{ "ER_UNKNOWN_COLLATION", 1273 },
|
||||
{ "ER_SLAVE_IGNORED_SSL_PARAMS", 1274 },
|
||||
{ "ER_SERVER_IS_IN_SECURE_AUTH_MODE", 1275 },
|
||||
{ "ER_WARN_FIELD_RESOLVED", 1276 },
|
||||
{ "ER_BAD_SLAVE_UNTIL_COND", 1277 },
|
||||
{ "ER_MISSING_SKIP_SLAVE", 1278 },
|
||||
{ "ER_UNTIL_COND_IGNORED", 1279 },
|
||||
{ "ER_WRONG_NAME_FOR_INDEX", 1280 },
|
||||
{ "ER_WRONG_NAME_FOR_CATALOG", 1281 },
|
||||
{ "ER_WARN_QC_RESIZE", 1282 },
|
||||
{ "ER_BAD_FT_COLUMN", 1283 },
|
||||
{ "ER_UNKNOWN_KEY_CACHE", 1284 },
|
||||
{ "ER_WARN_HOSTNAME_WONT_WORK", 1285 },
|
||||
{ "ER_UNKNOWN_STORAGE_ENGINE", 1286 },
|
||||
{ "ER_WARN_DEPRECATED_SYNTAX", 1287 },
|
||||
{ "ER_NON_UPDATABLE_TABLE", 1288 },
|
||||
{ "ER_FEATURE_DISABLED", 1289 },
|
||||
{ "ER_OPTION_PREVENTS_STATEMENT", 1290 },
|
||||
{ "ER_DUPLICATED_VALUE_IN_TYPE", 1291 },
|
||||
{ "ER_TRUNCATED_WRONG_VALUE", 1292 },
|
||||
{ "ER_TOO_MUCH_AUTO_TIMESTAMP_COLS", 1293 },
|
||||
{ "ER_INVALID_ON_UPDATE", 1294 },
|
||||
{ "ER_UNSUPPORTED_PS", 1295 },
|
||||
{ "ER_GET_ERRMSG", 1296 },
|
||||
{ "ER_GET_TEMPORARY_ERRMSG", 1297 },
|
||||
{ "ER_UNKNOWN_TIME_ZONE", 1298 },
|
||||
{ "ER_WARN_INVALID_TIMESTAMP", 1299 },
|
||||
{ "ER_INVALID_CHARACTER_STRING", 1300 },
|
||||
{ "ER_WARN_ALLOWED_PACKET_OVERFLOWED", 1301 },
|
||||
{ "ER_CONFLICTING_DECLARATIONS", 1302 },
|
||||
{ "ER_SP_NO_RECURSIVE_CREATE", 1303 },
|
||||
{ "ER_SP_ALREADY_EXISTS", 1304 },
|
||||
{ "ER_SP_DOES_NOT_EXIST", 1305 },
|
||||
{ "ER_SP_DROP_FAILED", 1306 },
|
||||
{ "ER_SP_STORE_FAILED", 1307 },
|
||||
{ "ER_SP_LILABEL_MISMATCH", 1308 },
|
||||
{ "ER_SP_LABEL_REDEFINE", 1309 },
|
||||
{ "ER_SP_LABEL_MISMATCH", 1310 },
|
||||
{ "ER_SP_UNINIT_VAR", 1311 },
|
||||
{ "ER_SP_BADSELECT", 1312 },
|
||||
{ "ER_SP_BADRETURN", 1313 },
|
||||
{ "ER_SP_BADSTATEMENT", 1314 },
|
||||
{ "ER_UPDATE_LOG_DEPRECATED_IGNORED", 1315 },
|
||||
{ "ER_UPDATE_LOG_DEPRECATED_TRANSLATED", 1316 },
|
||||
{ "ER_QUERY_INTERRUPTED", 1317 },
|
||||
{ "ER_SP_WRONG_NO_OF_ARGS", 1318 },
|
||||
{ "ER_SP_COND_MISMATCH", 1319 },
|
||||
{ "ER_SP_NORETURN", 1320 },
|
||||
{ "ER_SP_NORETURNEND", 1321 },
|
||||
{ "ER_SP_BAD_CURSOR_QUERY", 1322 },
|
||||
{ "ER_SP_BAD_CURSOR_SELECT", 1323 },
|
||||
{ "ER_SP_CURSOR_MISMATCH", 1324 },
|
||||
{ "ER_SP_CURSOR_ALREADY_OPEN", 1325 },
|
||||
{ "ER_SP_CURSOR_NOT_OPEN", 1326 },
|
||||
{ "ER_SP_UNDECLARED_VAR", 1327 },
|
||||
{ "ER_SP_WRONG_NO_OF_FETCH_ARGS", 1328 },
|
||||
{ "ER_SP_FETCH_NO_DATA", 1329 },
|
||||
{ "ER_SP_DUP_PARAM", 1330 },
|
||||
{ "ER_SP_DUP_VAR", 1331 },
|
||||
{ "ER_SP_DUP_COND", 1332 },
|
||||
{ "ER_SP_DUP_CURS", 1333 },
|
||||
{ "ER_SP_CANT_ALTER", 1334 },
|
||||
{ "ER_SP_SUBSELECT_NYI", 1335 },
|
||||
{ "ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG", 1336 },
|
||||
{ "ER_SP_VARCOND_AFTER_CURSHNDLR", 1337 },
|
||||
{ "ER_SP_CURSOR_AFTER_HANDLER", 1338 },
|
||||
{ "ER_SP_CASE_NOT_FOUND", 1339 },
|
||||
{ "ER_FPARSER_TOO_BIG_FILE", 1340 },
|
||||
{ "ER_FPARSER_BAD_HEADER", 1341 },
|
||||
{ "ER_FPARSER_EOF_IN_COMMENT", 1342 },
|
||||
{ "ER_FPARSER_ERROR_IN_PARAMETER", 1343 },
|
||||
{ "ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER", 1344 },
|
||||
{ "ER_VIEW_NO_EXPLAIN", 1345 },
|
||||
{ "ER_FRM_UNKNOWN_TYPE", 1346 },
|
||||
{ "ER_WRONG_OBJECT", 1347 },
|
||||
{ "ER_NONUPDATEABLE_COLUMN", 1348 },
|
||||
{ "ER_VIEW_SELECT_DERIVED", 1349 },
|
||||
{ "ER_VIEW_SELECT_CLAUSE", 1350 },
|
||||
{ "ER_VIEW_SELECT_VARIABLE", 1351 },
|
||||
{ "ER_VIEW_SELECT_TMPTABLE", 1352 },
|
||||
{ "ER_VIEW_WRONG_LIST", 1353 },
|
||||
{ "ER_WARN_VIEW_MERGE", 1354 },
|
||||
{ "ER_WARN_VIEW_WITHOUT_KEY", 1355 },
|
||||
{ "ER_VIEW_INVALID", 1356 },
|
||||
{ "ER_SP_NO_DROP_SP", 1357 },
|
||||
{ "ER_SP_GOTO_IN_HNDLR", 1358 },
|
||||
{ "ER_TRG_ALREADY_EXISTS", 1359 },
|
||||
{ "ER_TRG_DOES_NOT_EXIST", 1360 },
|
||||
{ "ER_TRG_ON_VIEW_OR_TEMP_TABLE", 1361 },
|
||||
{ "ER_TRG_CANT_CHANGE_ROW", 1362 },
|
||||
{ "ER_TRG_NO_SUCH_ROW_IN_TRG", 1363 },
|
||||
{ "ER_NO_DEFAULT_FOR_FIELD", 1364 },
|
||||
{ "ER_DIVISION_BY_ZERO", 1365 },
|
||||
{ "ER_TRUNCATED_WRONG_VALUE_FOR_FIELD", 1366 },
|
||||
{ "ER_ILLEGAL_VALUE_FOR_TYPE", 1367 },
|
||||
{ "ER_VIEW_NONUPD_CHECK", 1368 },
|
||||
{ "ER_VIEW_CHECK_FAILED", 1369 },
|
||||
{ "ER_PROCACCESS_DENIED_ERROR", 1370 },
|
||||
{ "ER_RELAY_LOG_FAIL", 1371 },
|
||||
{ "ER_PASSWD_LENGTH", 1372 },
|
||||
{ "ER_UNKNOWN_TARGET_BINLOG", 1373 },
|
||||
{ "ER_IO_ERR_LOG_INDEX_READ", 1374 },
|
||||
{ "ER_BINLOG_PURGE_PROHIBITED", 1375 },
|
||||
{ "ER_FSEEK_FAIL", 1376 },
|
||||
{ "ER_BINLOG_PURGE_FATAL_ERR", 1377 },
|
||||
{ "ER_LOG_IN_USE", 1378 },
|
||||
{ "ER_LOG_PURGE_UNKNOWN_ERR", 1379 },
|
||||
{ "ER_RELAY_LOG_INIT", 1380 },
|
||||
{ "ER_NO_BINARY_LOGGING", 1381 },
|
||||
{ "ER_RESERVED_SYNTAX", 1382 },
|
||||
{ "ER_WSAS_FAILED", 1383 },
|
||||
{ "ER_DIFF_GROUPS_PROC", 1384 },
|
||||
{ "ER_NO_GROUP_FOR_PROC", 1385 },
|
||||
{ "ER_ORDER_WITH_PROC", 1386 },
|
||||
{ "ER_LOGGING_PROHIBIT_CHANGING_OF", 1387 },
|
||||
{ "ER_NO_FILE_MAPPING", 1388 },
|
||||
{ "ER_WRONG_MAGIC", 1389 },
|
||||
{ "ER_PS_MANY_PARAM", 1390 },
|
||||
{ "ER_KEY_PART_0", 1391 },
|
||||
{ "ER_VIEW_CHECKSUM", 1392 },
|
||||
{ "ER_VIEW_MULTIUPDATE", 1393 },
|
||||
{ "ER_VIEW_NO_INSERT_FIELD_LIST", 1394 },
|
||||
{ "ER_VIEW_DELETE_MERGE_VIEW", 1395 },
|
||||
{ "ER_CANNOT_USER", 1396 },
|
||||
{ "ER_XAER_NOTA", 1397 },
|
||||
{ "ER_XAER_INVAL", 1398 },
|
||||
{ "ER_XAER_RMFAIL", 1399 },
|
||||
{ "ER_XAER_OUTSIDE", 1400 },
|
||||
{ "ER_XAER_RMERR", 1401 },
|
||||
{ "ER_XA_RBROLLBACK", 1402 },
|
||||
{ "ER_NONEXISTING_PROC_GRANT", 1403 },
|
||||
{ "ER_PROC_AUTO_GRANT_FAIL", 1404 },
|
||||
{ "ER_PROC_AUTO_REVOKE_FAIL", 1405 },
|
||||
{ "ER_DATA_TOO_LONG", 1406 },
|
||||
{ "ER_SP_BAD_SQLSTATE", 1407 },
|
||||
{ "ER_STARTUP", 1408 },
|
||||
{ "ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR", 1409 },
|
||||
{ "ER_CANT_CREATE_USER_WITH_GRANT", 1410 },
|
||||
{ "ER_WRONG_VALUE_FOR_TYPE", 1411 },
|
||||
{ "ER_TABLE_DEF_CHANGED", 1412 },
|
||||
{ "ER_SP_DUP_HANDLER", 1413 },
|
||||
{ "ER_SP_NOT_VAR_ARG", 1414 },
|
||||
{ "ER_SP_NO_RETSET", 1415 },
|
||||
{ "ER_CANT_CREATE_GEOMETRY_OBJECT", 1416 },
|
||||
{ "ER_FAILED_ROUTINE_BREAK_BINLOG", 1417 },
|
||||
{ "ER_BINLOG_UNSAFE_ROUTINE", 1418 },
|
||||
{ "ER_BINLOG_CREATE_ROUTINE_NEED_SUPER", 1419 },
|
||||
{ "ER_EXEC_STMT_WITH_OPEN_CURSOR", 1420 },
|
||||
{ "ER_STMT_HAS_NO_OPEN_CURSOR", 1421 },
|
||||
{ "ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG", 1422 },
|
||||
{ "ER_NO_DEFAULT_FOR_VIEW_FIELD", 1423 },
|
||||
{ "ER_SP_NO_RECURSION", 1424 },
|
||||
{ "ER_TOO_BIG_SCALE", 1425 },
|
||||
{ "ER_TOO_BIG_PRECISION", 1426 },
|
||||
{ "ER_M_BIGGER_THAN_D", 1427 },
|
||||
{ "ER_WRONG_LOCK_OF_SYSTEM_TABLE", 1428 },
|
||||
{ "ER_CONNECT_TO_FOREIGN_DATA_SOURCE", 1429 },
|
||||
{ "ER_QUERY_ON_FOREIGN_DATA_SOURCE", 1430 },
|
||||
{ "ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST", 1431 },
|
||||
{ "ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE", 1432 },
|
||||
{ "ER_FOREIGN_DATA_STRING_INVALID", 1433 },
|
||||
{ "ER_CANT_CREATE_FEDERATED_TABLE", 1434 },
|
||||
{ "ER_TRG_IN_WRONG_SCHEMA", 1435 },
|
||||
{ "ER_STACK_OVERRUN_NEED_MORE", 1436 },
|
||||
{ "ER_TOO_LONG_BODY", 1437 },
|
||||
{ "ER_WARN_CANT_DROP_DEFAULT_KEYCACHE", 1438 },
|
||||
{ "ER_TOO_BIG_DISPLAYWIDTH", 1439 },
|
||||
{ "ER_XAER_DUPID", 1440 },
|
||||
{ "ER_DATETIME_FUNCTION_OVERFLOW", 1441 },
|
||||
{ "ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG", 1442 },
|
||||
{ "ER_VIEW_PREVENT_UPDATE", 1443 },
|
||||
{ "ER_PS_NO_RECURSION", 1444 },
|
||||
{ "ER_SP_CANT_SET_AUTOCOMMIT", 1445 },
|
||||
{ "ER_NO_VIEW_USER", 1446 },
|
||||
{ "ER_VIEW_FRM_NO_USER", 1447 },
|
||||
{ "ER_VIEW_OTHER_USER", 1448 },
|
||||
{ "ER_NO_SUCH_USER", 1449 },
|
||||
{ "ER_FORBID_SCHEMA_CHANGE", 1450 },
|
||||
{ "ER_ROW_IS_REFERENCED_2", 1451 },
|
||||
{ "ER_NO_REFERENCED_ROW_2", 1452 },
|
||||
{ "ER_SP_BAD_VAR_SHADOW", 1453 },
|
||||
+458
@@ -0,0 +1,458 @@
|
||||
/* Autogenerated file, please don't edit */
|
||||
|
||||
#define ER_ERROR_FIRST 1000
|
||||
#define ER_HASHCHK 1000
|
||||
#define ER_NISAMCHK 1001
|
||||
#define ER_NO 1002
|
||||
#define ER_YES 1003
|
||||
#define ER_CANT_CREATE_FILE 1004
|
||||
#define ER_CANT_CREATE_TABLE 1005
|
||||
#define ER_CANT_CREATE_DB 1006
|
||||
#define ER_DB_CREATE_EXISTS 1007
|
||||
#define ER_DB_DROP_EXISTS 1008
|
||||
#define ER_DB_DROP_DELETE 1009
|
||||
#define ER_DB_DROP_RMDIR 1010
|
||||
#define ER_CANT_DELETE_FILE 1011
|
||||
#define ER_CANT_FIND_SYSTEM_REC 1012
|
||||
#define ER_CANT_GET_STAT 1013
|
||||
#define ER_CANT_GET_WD 1014
|
||||
#define ER_CANT_LOCK 1015
|
||||
#define ER_CANT_OPEN_FILE 1016
|
||||
#define ER_FILE_NOT_FOUND 1017
|
||||
#define ER_CANT_READ_DIR 1018
|
||||
#define ER_CANT_SET_WD 1019
|
||||
#define ER_CHECKREAD 1020
|
||||
#define ER_DISK_FULL 1021
|
||||
#define ER_DUP_KEY 1022
|
||||
#define ER_ERROR_ON_CLOSE 1023
|
||||
#define ER_ERROR_ON_READ 1024
|
||||
#define ER_ERROR_ON_RENAME 1025
|
||||
#define ER_ERROR_ON_WRITE 1026
|
||||
#define ER_FILE_USED 1027
|
||||
#define ER_FILSORT_ABORT 1028
|
||||
#define ER_FORM_NOT_FOUND 1029
|
||||
#define ER_GET_ERRNO 1030
|
||||
#define ER_ILLEGAL_HA 1031
|
||||
#define ER_KEY_NOT_FOUND 1032
|
||||
#define ER_NOT_FORM_FILE 1033
|
||||
#define ER_NOT_KEYFILE 1034
|
||||
#define ER_OLD_KEYFILE 1035
|
||||
#define ER_OPEN_AS_READONLY 1036
|
||||
#define ER_OUTOFMEMORY 1037
|
||||
#define ER_OUT_OF_SORTMEMORY 1038
|
||||
#define ER_UNEXPECTED_EOF 1039
|
||||
#define ER_CON_COUNT_ERROR 1040
|
||||
#define ER_OUT_OF_RESOURCES 1041
|
||||
#define ER_BAD_HOST_ERROR 1042
|
||||
#define ER_HANDSHAKE_ERROR 1043
|
||||
#define ER_DBACCESS_DENIED_ERROR 1044
|
||||
#define ER_ACCESS_DENIED_ERROR 1045
|
||||
#define ER_NO_DB_ERROR 1046
|
||||
#define ER_UNKNOWN_COM_ERROR 1047
|
||||
#define ER_BAD_NULL_ERROR 1048
|
||||
#define ER_BAD_DB_ERROR 1049
|
||||
#define ER_TABLE_EXISTS_ERROR 1050
|
||||
#define ER_BAD_TABLE_ERROR 1051
|
||||
#define ER_NON_UNIQ_ERROR 1052
|
||||
#define ER_SERVER_SHUTDOWN 1053
|
||||
#define ER_BAD_FIELD_ERROR 1054
|
||||
#define ER_WRONG_FIELD_WITH_GROUP 1055
|
||||
#define ER_WRONG_GROUP_FIELD 1056
|
||||
#define ER_WRONG_SUM_SELECT 1057
|
||||
#define ER_WRONG_VALUE_COUNT 1058
|
||||
#define ER_TOO_LONG_IDENT 1059
|
||||
#define ER_DUP_FIELDNAME 1060
|
||||
#define ER_DUP_KEYNAME 1061
|
||||
#define ER_DUP_ENTRY 1062
|
||||
#define ER_WRONG_FIELD_SPEC 1063
|
||||
#define ER_PARSE_ERROR 1064
|
||||
#define ER_EMPTY_QUERY 1065
|
||||
#define ER_NONUNIQ_TABLE 1066
|
||||
#define ER_INVALID_DEFAULT 1067
|
||||
#define ER_MULTIPLE_PRI_KEY 1068
|
||||
#define ER_TOO_MANY_KEYS 1069
|
||||
#define ER_TOO_MANY_KEY_PARTS 1070
|
||||
#define ER_TOO_LONG_KEY 1071
|
||||
#define ER_KEY_COLUMN_DOES_NOT_EXITS 1072
|
||||
#define ER_BLOB_USED_AS_KEY 1073
|
||||
#define ER_TOO_BIG_FIELDLENGTH 1074
|
||||
#define ER_WRONG_AUTO_KEY 1075
|
||||
#define ER_READY 1076
|
||||
#define ER_NORMAL_SHUTDOWN 1077
|
||||
#define ER_GOT_SIGNAL 1078
|
||||
#define ER_SHUTDOWN_COMPLETE 1079
|
||||
#define ER_FORCING_CLOSE 1080
|
||||
#define ER_IPSOCK_ERROR 1081
|
||||
#define ER_NO_SUCH_INDEX 1082
|
||||
#define ER_WRONG_FIELD_TERMINATORS 1083
|
||||
#define ER_BLOBS_AND_NO_TERMINATED 1084
|
||||
#define ER_TEXTFILE_NOT_READABLE 1085
|
||||
#define ER_FILE_EXISTS_ERROR 1086
|
||||
#define ER_LOAD_INFO 1087
|
||||
#define ER_ALTER_INFO 1088
|
||||
#define ER_WRONG_SUB_KEY 1089
|
||||
#define ER_CANT_REMOVE_ALL_FIELDS 1090
|
||||
#define ER_CANT_DROP_FIELD_OR_KEY 1091
|
||||
#define ER_INSERT_INFO 1092
|
||||
#define ER_UPDATE_TABLE_USED 1093
|
||||
#define ER_NO_SUCH_THREAD 1094
|
||||
#define ER_KILL_DENIED_ERROR 1095
|
||||
#define ER_NO_TABLES_USED 1096
|
||||
#define ER_TOO_BIG_SET 1097
|
||||
#define ER_NO_UNIQUE_LOGFILE 1098
|
||||
#define ER_TABLE_NOT_LOCKED_FOR_WRITE 1099
|
||||
#define ER_TABLE_NOT_LOCKED 1100
|
||||
#define ER_BLOB_CANT_HAVE_DEFAULT 1101
|
||||
#define ER_WRONG_DB_NAME 1102
|
||||
#define ER_WRONG_TABLE_NAME 1103
|
||||
#define ER_TOO_BIG_SELECT 1104
|
||||
#define ER_UNKNOWN_ERROR 1105
|
||||
#define ER_UNKNOWN_PROCEDURE 1106
|
||||
#define ER_WRONG_PARAMCOUNT_TO_PROCEDURE 1107
|
||||
#define ER_WRONG_PARAMETERS_TO_PROCEDURE 1108
|
||||
#define ER_UNKNOWN_TABLE 1109
|
||||
#define ER_FIELD_SPECIFIED_TWICE 1110
|
||||
#define ER_INVALID_GROUP_FUNC_USE 1111
|
||||
#define ER_UNSUPPORTED_EXTENSION 1112
|
||||
#define ER_TABLE_MUST_HAVE_COLUMNS 1113
|
||||
#define ER_RECORD_FILE_FULL 1114
|
||||
#define ER_UNKNOWN_CHARACTER_SET 1115
|
||||
#define ER_TOO_MANY_TABLES 1116
|
||||
#define ER_TOO_MANY_FIELDS 1117
|
||||
#define ER_TOO_BIG_ROWSIZE 1118
|
||||
#define ER_STACK_OVERRUN 1119
|
||||
#define ER_WRONG_OUTER_JOIN 1120
|
||||
#define ER_NULL_COLUMN_IN_INDEX 1121
|
||||
#define ER_CANT_FIND_UDF 1122
|
||||
#define ER_CANT_INITIALIZE_UDF 1123
|
||||
#define ER_UDF_NO_PATHS 1124
|
||||
#define ER_UDF_EXISTS 1125
|
||||
#define ER_CANT_OPEN_LIBRARY 1126
|
||||
#define ER_CANT_FIND_DL_ENTRY 1127
|
||||
#define ER_FUNCTION_NOT_DEFINED 1128
|
||||
#define ER_HOST_IS_BLOCKED 1129
|
||||
#define ER_HOST_NOT_PRIVILEGED 1130
|
||||
#define ER_PASSWORD_ANONYMOUS_USER 1131
|
||||
#define ER_PASSWORD_NOT_ALLOWED 1132
|
||||
#define ER_PASSWORD_NO_MATCH 1133
|
||||
#define ER_UPDATE_INFO 1134
|
||||
#define ER_CANT_CREATE_THREAD 1135
|
||||
#define ER_WRONG_VALUE_COUNT_ON_ROW 1136
|
||||
#define ER_CANT_REOPEN_TABLE 1137
|
||||
#define ER_INVALID_USE_OF_NULL 1138
|
||||
#define ER_REGEXP_ERROR 1139
|
||||
#define ER_MIX_OF_GROUP_FUNC_AND_FIELDS 1140
|
||||
#define ER_NONEXISTING_GRANT 1141
|
||||
#define ER_TABLEACCESS_DENIED_ERROR 1142
|
||||
#define ER_COLUMNACCESS_DENIED_ERROR 1143
|
||||
#define ER_ILLEGAL_GRANT_FOR_TABLE 1144
|
||||
#define ER_GRANT_WRONG_HOST_OR_USER 1145
|
||||
#define ER_NO_SUCH_TABLE 1146
|
||||
#define ER_NONEXISTING_TABLE_GRANT 1147
|
||||
#define ER_NOT_ALLOWED_COMMAND 1148
|
||||
#define ER_SYNTAX_ERROR 1149
|
||||
#define ER_DELAYED_CANT_CHANGE_LOCK 1150
|
||||
#define ER_TOO_MANY_DELAYED_THREADS 1151
|
||||
#define ER_ABORTING_CONNECTION 1152
|
||||
#define ER_NET_PACKET_TOO_LARGE 1153
|
||||
#define ER_NET_READ_ERROR_FROM_PIPE 1154
|
||||
#define ER_NET_FCNTL_ERROR 1155
|
||||
#define ER_NET_PACKETS_OUT_OF_ORDER 1156
|
||||
#define ER_NET_UNCOMPRESS_ERROR 1157
|
||||
#define ER_NET_READ_ERROR 1158
|
||||
#define ER_NET_READ_INTERRUPTED 1159
|
||||
#define ER_NET_ERROR_ON_WRITE 1160
|
||||
#define ER_NET_WRITE_INTERRUPTED 1161
|
||||
#define ER_TOO_LONG_STRING 1162
|
||||
#define ER_TABLE_CANT_HANDLE_BLOB 1163
|
||||
#define ER_TABLE_CANT_HANDLE_AUTO_INCREMENT 1164
|
||||
#define ER_DELAYED_INSERT_TABLE_LOCKED 1165
|
||||
#define ER_WRONG_COLUMN_NAME 1166
|
||||
#define ER_WRONG_KEY_COLUMN 1167
|
||||
#define ER_WRONG_MRG_TABLE 1168
|
||||
#define ER_DUP_UNIQUE 1169
|
||||
#define ER_BLOB_KEY_WITHOUT_LENGTH 1170
|
||||
#define ER_PRIMARY_CANT_HAVE_NULL 1171
|
||||
#define ER_TOO_MANY_ROWS 1172
|
||||
#define ER_REQUIRES_PRIMARY_KEY 1173
|
||||
#define ER_NO_RAID_COMPILED 1174
|
||||
#define ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE 1175
|
||||
#define ER_KEY_DOES_NOT_EXITS 1176
|
||||
#define ER_CHECK_NO_SUCH_TABLE 1177
|
||||
#define ER_CHECK_NOT_IMPLEMENTED 1178
|
||||
#define ER_CANT_DO_THIS_DURING_AN_TRANSACTION 1179
|
||||
#define ER_ERROR_DURING_COMMIT 1180
|
||||
#define ER_ERROR_DURING_ROLLBACK 1181
|
||||
#define ER_ERROR_DURING_FLUSH_LOGS 1182
|
||||
#define ER_ERROR_DURING_CHECKPOINT 1183
|
||||
#define ER_NEW_ABORTING_CONNECTION 1184
|
||||
#define ER_DUMP_NOT_IMPLEMENTED 1185
|
||||
#define ER_FLUSH_MASTER_BINLOG_CLOSED 1186
|
||||
#define ER_INDEX_REBUILD 1187
|
||||
#define ER_MASTER 1188
|
||||
#define ER_MASTER_NET_READ 1189
|
||||
#define ER_MASTER_NET_WRITE 1190
|
||||
#define ER_FT_MATCHING_KEY_NOT_FOUND 1191
|
||||
#define ER_LOCK_OR_ACTIVE_TRANSACTION 1192
|
||||
#define ER_UNKNOWN_SYSTEM_VARIABLE 1193
|
||||
#define ER_CRASHED_ON_USAGE 1194
|
||||
#define ER_CRASHED_ON_REPAIR 1195
|
||||
#define ER_WARNING_NOT_COMPLETE_ROLLBACK 1196
|
||||
#define ER_TRANS_CACHE_FULL 1197
|
||||
#define ER_SLAVE_MUST_STOP 1198
|
||||
#define ER_SLAVE_NOT_RUNNING 1199
|
||||
#define ER_BAD_SLAVE 1200
|
||||
#define ER_MASTER_INFO 1201
|
||||
#define ER_SLAVE_THREAD 1202
|
||||
#define ER_TOO_MANY_USER_CONNECTIONS 1203
|
||||
#define ER_SET_CONSTANTS_ONLY 1204
|
||||
#define ER_LOCK_WAIT_TIMEOUT 1205
|
||||
#define ER_LOCK_TABLE_FULL 1206
|
||||
#define ER_READ_ONLY_TRANSACTION 1207
|
||||
#define ER_DROP_DB_WITH_READ_LOCK 1208
|
||||
#define ER_CREATE_DB_WITH_READ_LOCK 1209
|
||||
#define ER_WRONG_ARGUMENTS 1210
|
||||
#define ER_NO_PERMISSION_TO_CREATE_USER 1211
|
||||
#define ER_UNION_TABLES_IN_DIFFERENT_DIR 1212
|
||||
#define ER_LOCK_DEADLOCK 1213
|
||||
#define ER_TABLE_CANT_HANDLE_FT 1214
|
||||
#define ER_CANNOT_ADD_FOREIGN 1215
|
||||
#define ER_NO_REFERENCED_ROW 1216
|
||||
#define ER_ROW_IS_REFERENCED 1217
|
||||
#define ER_CONNECT_TO_MASTER 1218
|
||||
#define ER_QUERY_ON_MASTER 1219
|
||||
#define ER_ERROR_WHEN_EXECUTING_COMMAND 1220
|
||||
#define ER_WRONG_USAGE 1221
|
||||
#define ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT 1222
|
||||
#define ER_CANT_UPDATE_WITH_READLOCK 1223
|
||||
#define ER_MIXING_NOT_ALLOWED 1224
|
||||
#define ER_DUP_ARGUMENT 1225
|
||||
#define ER_USER_LIMIT_REACHED 1226
|
||||
#define ER_SPECIFIC_ACCESS_DENIED_ERROR 1227
|
||||
#define ER_LOCAL_VARIABLE 1228
|
||||
#define ER_GLOBAL_VARIABLE 1229
|
||||
#define ER_NO_DEFAULT 1230
|
||||
#define ER_WRONG_VALUE_FOR_VAR 1231
|
||||
#define ER_WRONG_TYPE_FOR_VAR 1232
|
||||
#define ER_VAR_CANT_BE_READ 1233
|
||||
#define ER_CANT_USE_OPTION_HERE 1234
|
||||
#define ER_NOT_SUPPORTED_YET 1235
|
||||
#define ER_MASTER_FATAL_ERROR_READING_BINLOG 1236
|
||||
#define ER_SLAVE_IGNORED_TABLE 1237
|
||||
#define ER_INCORRECT_GLOBAL_LOCAL_VAR 1238
|
||||
#define ER_WRONG_FK_DEF 1239
|
||||
#define ER_KEY_REF_DO_NOT_MATCH_TABLE_REF 1240
|
||||
#define ER_OPERAND_COLUMNS 1241
|
||||
#define ER_SUBQUERY_NO_1_ROW 1242
|
||||
#define ER_UNKNOWN_STMT_HANDLER 1243
|
||||
#define ER_CORRUPT_HELP_DB 1244
|
||||
#define ER_CYCLIC_REFERENCE 1245
|
||||
#define ER_AUTO_CONVERT 1246
|
||||
#define ER_ILLEGAL_REFERENCE 1247
|
||||
#define ER_DERIVED_MUST_HAVE_ALIAS 1248
|
||||
#define ER_SELECT_REDUCED 1249
|
||||
#define ER_TABLENAME_NOT_ALLOWED_HERE 1250
|
||||
#define ER_NOT_SUPPORTED_AUTH_MODE 1251
|
||||
#define ER_SPATIAL_CANT_HAVE_NULL 1252
|
||||
#define ER_COLLATION_CHARSET_MISMATCH 1253
|
||||
#define ER_SLAVE_WAS_RUNNING 1254
|
||||
#define ER_SLAVE_WAS_NOT_RUNNING 1255
|
||||
#define ER_TOO_BIG_FOR_UNCOMPRESS 1256
|
||||
#define ER_ZLIB_Z_MEM_ERROR 1257
|
||||
#define ER_ZLIB_Z_BUF_ERROR 1258
|
||||
#define ER_ZLIB_Z_DATA_ERROR 1259
|
||||
#define ER_CUT_VALUE_GROUP_CONCAT 1260
|
||||
#define ER_WARN_TOO_FEW_RECORDS 1261
|
||||
#define ER_WARN_TOO_MANY_RECORDS 1262
|
||||
#define ER_WARN_NULL_TO_NOTNULL 1263
|
||||
#define ER_WARN_DATA_OUT_OF_RANGE 1264
|
||||
#define WARN_DATA_TRUNCATED 1265
|
||||
#define ER_WARN_USING_OTHER_HANDLER 1266
|
||||
#define ER_CANT_AGGREGATE_2COLLATIONS 1267
|
||||
#define ER_DROP_USER 1268
|
||||
#define ER_REVOKE_GRANTS 1269
|
||||
#define ER_CANT_AGGREGATE_3COLLATIONS 1270
|
||||
#define ER_CANT_AGGREGATE_NCOLLATIONS 1271
|
||||
#define ER_VARIABLE_IS_NOT_STRUCT 1272
|
||||
#define ER_UNKNOWN_COLLATION 1273
|
||||
#define ER_SLAVE_IGNORED_SSL_PARAMS 1274
|
||||
#define ER_SERVER_IS_IN_SECURE_AUTH_MODE 1275
|
||||
#define ER_WARN_FIELD_RESOLVED 1276
|
||||
#define ER_BAD_SLAVE_UNTIL_COND 1277
|
||||
#define ER_MISSING_SKIP_SLAVE 1278
|
||||
#define ER_UNTIL_COND_IGNORED 1279
|
||||
#define ER_WRONG_NAME_FOR_INDEX 1280
|
||||
#define ER_WRONG_NAME_FOR_CATALOG 1281
|
||||
#define ER_WARN_QC_RESIZE 1282
|
||||
#define ER_BAD_FT_COLUMN 1283
|
||||
#define ER_UNKNOWN_KEY_CACHE 1284
|
||||
#define ER_WARN_HOSTNAME_WONT_WORK 1285
|
||||
#define ER_UNKNOWN_STORAGE_ENGINE 1286
|
||||
#define ER_WARN_DEPRECATED_SYNTAX 1287
|
||||
#define ER_NON_UPDATABLE_TABLE 1288
|
||||
#define ER_FEATURE_DISABLED 1289
|
||||
#define ER_OPTION_PREVENTS_STATEMENT 1290
|
||||
#define ER_DUPLICATED_VALUE_IN_TYPE 1291
|
||||
#define ER_TRUNCATED_WRONG_VALUE 1292
|
||||
#define ER_TOO_MUCH_AUTO_TIMESTAMP_COLS 1293
|
||||
#define ER_INVALID_ON_UPDATE 1294
|
||||
#define ER_UNSUPPORTED_PS 1295
|
||||
#define ER_GET_ERRMSG 1296
|
||||
#define ER_GET_TEMPORARY_ERRMSG 1297
|
||||
#define ER_UNKNOWN_TIME_ZONE 1298
|
||||
#define ER_WARN_INVALID_TIMESTAMP 1299
|
||||
#define ER_INVALID_CHARACTER_STRING 1300
|
||||
#define ER_WARN_ALLOWED_PACKET_OVERFLOWED 1301
|
||||
#define ER_CONFLICTING_DECLARATIONS 1302
|
||||
#define ER_SP_NO_RECURSIVE_CREATE 1303
|
||||
#define ER_SP_ALREADY_EXISTS 1304
|
||||
#define ER_SP_DOES_NOT_EXIST 1305
|
||||
#define ER_SP_DROP_FAILED 1306
|
||||
#define ER_SP_STORE_FAILED 1307
|
||||
#define ER_SP_LILABEL_MISMATCH 1308
|
||||
#define ER_SP_LABEL_REDEFINE 1309
|
||||
#define ER_SP_LABEL_MISMATCH 1310
|
||||
#define ER_SP_UNINIT_VAR 1311
|
||||
#define ER_SP_BADSELECT 1312
|
||||
#define ER_SP_BADRETURN 1313
|
||||
#define ER_SP_BADSTATEMENT 1314
|
||||
#define ER_UPDATE_LOG_DEPRECATED_IGNORED 1315
|
||||
#define ER_UPDATE_LOG_DEPRECATED_TRANSLATED 1316
|
||||
#define ER_QUERY_INTERRUPTED 1317
|
||||
#define ER_SP_WRONG_NO_OF_ARGS 1318
|
||||
#define ER_SP_COND_MISMATCH 1319
|
||||
#define ER_SP_NORETURN 1320
|
||||
#define ER_SP_NORETURNEND 1321
|
||||
#define ER_SP_BAD_CURSOR_QUERY 1322
|
||||
#define ER_SP_BAD_CURSOR_SELECT 1323
|
||||
#define ER_SP_CURSOR_MISMATCH 1324
|
||||
#define ER_SP_CURSOR_ALREADY_OPEN 1325
|
||||
#define ER_SP_CURSOR_NOT_OPEN 1326
|
||||
#define ER_SP_UNDECLARED_VAR 1327
|
||||
#define ER_SP_WRONG_NO_OF_FETCH_ARGS 1328
|
||||
#define ER_SP_FETCH_NO_DATA 1329
|
||||
#define ER_SP_DUP_PARAM 1330
|
||||
#define ER_SP_DUP_VAR 1331
|
||||
#define ER_SP_DUP_COND 1332
|
||||
#define ER_SP_DUP_CURS 1333
|
||||
#define ER_SP_CANT_ALTER 1334
|
||||
#define ER_SP_SUBSELECT_NYI 1335
|
||||
#define ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG 1336
|
||||
#define ER_SP_VARCOND_AFTER_CURSHNDLR 1337
|
||||
#define ER_SP_CURSOR_AFTER_HANDLER 1338
|
||||
#define ER_SP_CASE_NOT_FOUND 1339
|
||||
#define ER_FPARSER_TOO_BIG_FILE 1340
|
||||
#define ER_FPARSER_BAD_HEADER 1341
|
||||
#define ER_FPARSER_EOF_IN_COMMENT 1342
|
||||
#define ER_FPARSER_ERROR_IN_PARAMETER 1343
|
||||
#define ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER 1344
|
||||
#define ER_VIEW_NO_EXPLAIN 1345
|
||||
#define ER_FRM_UNKNOWN_TYPE 1346
|
||||
#define ER_WRONG_OBJECT 1347
|
||||
#define ER_NONUPDATEABLE_COLUMN 1348
|
||||
#define ER_VIEW_SELECT_DERIVED 1349
|
||||
#define ER_VIEW_SELECT_CLAUSE 1350
|
||||
#define ER_VIEW_SELECT_VARIABLE 1351
|
||||
#define ER_VIEW_SELECT_TMPTABLE 1352
|
||||
#define ER_VIEW_WRONG_LIST 1353
|
||||
#define ER_WARN_VIEW_MERGE 1354
|
||||
#define ER_WARN_VIEW_WITHOUT_KEY 1355
|
||||
#define ER_VIEW_INVALID 1356
|
||||
#define ER_SP_NO_DROP_SP 1357
|
||||
#define ER_SP_GOTO_IN_HNDLR 1358
|
||||
#define ER_TRG_ALREADY_EXISTS 1359
|
||||
#define ER_TRG_DOES_NOT_EXIST 1360
|
||||
#define ER_TRG_ON_VIEW_OR_TEMP_TABLE 1361
|
||||
#define ER_TRG_CANT_CHANGE_ROW 1362
|
||||
#define ER_TRG_NO_SUCH_ROW_IN_TRG 1363
|
||||
#define ER_NO_DEFAULT_FOR_FIELD 1364
|
||||
#define ER_DIVISION_BY_ZERO 1365
|
||||
#define ER_TRUNCATED_WRONG_VALUE_FOR_FIELD 1366
|
||||
#define ER_ILLEGAL_VALUE_FOR_TYPE 1367
|
||||
#define ER_VIEW_NONUPD_CHECK 1368
|
||||
#define ER_VIEW_CHECK_FAILED 1369
|
||||
#define ER_PROCACCESS_DENIED_ERROR 1370
|
||||
#define ER_RELAY_LOG_FAIL 1371
|
||||
#define ER_PASSWD_LENGTH 1372
|
||||
#define ER_UNKNOWN_TARGET_BINLOG 1373
|
||||
#define ER_IO_ERR_LOG_INDEX_READ 1374
|
||||
#define ER_BINLOG_PURGE_PROHIBITED 1375
|
||||
#define ER_FSEEK_FAIL 1376
|
||||
#define ER_BINLOG_PURGE_FATAL_ERR 1377
|
||||
#define ER_LOG_IN_USE 1378
|
||||
#define ER_LOG_PURGE_UNKNOWN_ERR 1379
|
||||
#define ER_RELAY_LOG_INIT 1380
|
||||
#define ER_NO_BINARY_LOGGING 1381
|
||||
#define ER_RESERVED_SYNTAX 1382
|
||||
#define ER_WSAS_FAILED 1383
|
||||
#define ER_DIFF_GROUPS_PROC 1384
|
||||
#define ER_NO_GROUP_FOR_PROC 1385
|
||||
#define ER_ORDER_WITH_PROC 1386
|
||||
#define ER_LOGGING_PROHIBIT_CHANGING_OF 1387
|
||||
#define ER_NO_FILE_MAPPING 1388
|
||||
#define ER_WRONG_MAGIC 1389
|
||||
#define ER_PS_MANY_PARAM 1390
|
||||
#define ER_KEY_PART_0 1391
|
||||
#define ER_VIEW_CHECKSUM 1392
|
||||
#define ER_VIEW_MULTIUPDATE 1393
|
||||
#define ER_VIEW_NO_INSERT_FIELD_LIST 1394
|
||||
#define ER_VIEW_DELETE_MERGE_VIEW 1395
|
||||
#define ER_CANNOT_USER 1396
|
||||
#define ER_XAER_NOTA 1397
|
||||
#define ER_XAER_INVAL 1398
|
||||
#define ER_XAER_RMFAIL 1399
|
||||
#define ER_XAER_OUTSIDE 1400
|
||||
#define ER_XAER_RMERR 1401
|
||||
#define ER_XA_RBROLLBACK 1402
|
||||
#define ER_NONEXISTING_PROC_GRANT 1403
|
||||
#define ER_PROC_AUTO_GRANT_FAIL 1404
|
||||
#define ER_PROC_AUTO_REVOKE_FAIL 1405
|
||||
#define ER_DATA_TOO_LONG 1406
|
||||
#define ER_SP_BAD_SQLSTATE 1407
|
||||
#define ER_STARTUP 1408
|
||||
#define ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR 1409
|
||||
#define ER_CANT_CREATE_USER_WITH_GRANT 1410
|
||||
#define ER_WRONG_VALUE_FOR_TYPE 1411
|
||||
#define ER_TABLE_DEF_CHANGED 1412
|
||||
#define ER_SP_DUP_HANDLER 1413
|
||||
#define ER_SP_NOT_VAR_ARG 1414
|
||||
#define ER_SP_NO_RETSET 1415
|
||||
#define ER_CANT_CREATE_GEOMETRY_OBJECT 1416
|
||||
#define ER_FAILED_ROUTINE_BREAK_BINLOG 1417
|
||||
#define ER_BINLOG_UNSAFE_ROUTINE 1418
|
||||
#define ER_BINLOG_CREATE_ROUTINE_NEED_SUPER 1419
|
||||
#define ER_EXEC_STMT_WITH_OPEN_CURSOR 1420
|
||||
#define ER_STMT_HAS_NO_OPEN_CURSOR 1421
|
||||
#define ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG 1422
|
||||
#define ER_NO_DEFAULT_FOR_VIEW_FIELD 1423
|
||||
#define ER_SP_NO_RECURSION 1424
|
||||
#define ER_TOO_BIG_SCALE 1425
|
||||
#define ER_TOO_BIG_PRECISION 1426
|
||||
#define ER_M_BIGGER_THAN_D 1427
|
||||
#define ER_WRONG_LOCK_OF_SYSTEM_TABLE 1428
|
||||
#define ER_CONNECT_TO_FOREIGN_DATA_SOURCE 1429
|
||||
#define ER_QUERY_ON_FOREIGN_DATA_SOURCE 1430
|
||||
#define ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST 1431
|
||||
#define ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE 1432
|
||||
#define ER_FOREIGN_DATA_STRING_INVALID 1433
|
||||
#define ER_CANT_CREATE_FEDERATED_TABLE 1434
|
||||
#define ER_TRG_IN_WRONG_SCHEMA 1435
|
||||
#define ER_STACK_OVERRUN_NEED_MORE 1436
|
||||
#define ER_TOO_LONG_BODY 1437
|
||||
#define ER_WARN_CANT_DROP_DEFAULT_KEYCACHE 1438
|
||||
#define ER_TOO_BIG_DISPLAYWIDTH 1439
|
||||
#define ER_XAER_DUPID 1440
|
||||
#define ER_DATETIME_FUNCTION_OVERFLOW 1441
|
||||
#define ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG 1442
|
||||
#define ER_VIEW_PREVENT_UPDATE 1443
|
||||
#define ER_PS_NO_RECURSION 1444
|
||||
#define ER_SP_CANT_SET_AUTOCOMMIT 1445
|
||||
#define ER_NO_VIEW_USER 1446
|
||||
#define ER_VIEW_FRM_NO_USER 1447
|
||||
#define ER_VIEW_OTHER_USER 1448
|
||||
#define ER_NO_SUCH_USER 1449
|
||||
#define ER_FORBID_SCHEMA_CHANGE 1450
|
||||
#define ER_ROW_IS_REFERENCED_2 1451
|
||||
#define ER_NO_REFERENCED_ROW_2 1452
|
||||
#define ER_SP_BAD_VAR_SHADOW 1453
|
||||
#define ER_ERROR_LAST 1453
|
||||
Vendored
+183
@@ -0,0 +1,183 @@
|
||||
/*
|
||||
* Module: sched.h
|
||||
*
|
||||
* Purpose:
|
||||
* Provides an implementation of POSIX realtime extensions
|
||||
* as defined in
|
||||
*
|
||||
* POSIX 1003.1b-1993 (POSIX.1b)
|
||||
*
|
||||
* --------------------------------------------------------------------------
|
||||
*
|
||||
* Pthreads-win32 - POSIX Threads Library for Win32
|
||||
* Copyright(C) 1998 John E. Bossom
|
||||
* Copyright(C) 1999,2005 Pthreads-win32 contributors
|
||||
*
|
||||
* Contact Email: rpj@callisto.canberra.edu.au
|
||||
*
|
||||
* The current list of contributors is contained
|
||||
* in the file CONTRIBUTORS included with the source
|
||||
* code distribution. The list can also be seen at the
|
||||
* following World Wide Web location:
|
||||
* http://sources.redhat.com/pthreads-win32/contributors.html
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser 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,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING.LIB;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
||||
*/
|
||||
#if !defined(_SCHED_H)
|
||||
#define _SCHED_H
|
||||
|
||||
#undef PTW32_SCHED_LEVEL
|
||||
|
||||
#if defined(_POSIX_SOURCE)
|
||||
#define PTW32_SCHED_LEVEL 0
|
||||
/* Early POSIX */
|
||||
#endif
|
||||
|
||||
#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
|
||||
#undef PTW32_SCHED_LEVEL
|
||||
#define PTW32_SCHED_LEVEL 1
|
||||
/* Include 1b, 1c and 1d */
|
||||
#endif
|
||||
|
||||
#if defined(INCLUDE_NP)
|
||||
#undef PTW32_SCHED_LEVEL
|
||||
#define PTW32_SCHED_LEVEL 2
|
||||
/* Include Non-Portable extensions */
|
||||
#endif
|
||||
|
||||
#define PTW32_SCHED_LEVEL_MAX 3
|
||||
|
||||
#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 ) || !defined(PTW32_SCHED_LEVEL)
|
||||
#define PTW32_SCHED_LEVEL PTW32_SCHED_LEVEL_MAX
|
||||
/* Include everything */
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(__GNUC__) && !defined(__declspec)
|
||||
# error Please upgrade your GNU compiler to one that supports __declspec.
|
||||
#endif
|
||||
|
||||
/*
|
||||
* When building the library, you should define PTW32_BUILD so that
|
||||
* the variables/functions are exported correctly. When using the library,
|
||||
* do NOT define PTW32_BUILD, and then the variables/functions will
|
||||
* be imported correctly.
|
||||
*/
|
||||
#if !defined(PTW32_STATIC_LIB)
|
||||
# if defined(PTW32_BUILD)
|
||||
# define PTW32_DLLPORT __declspec (dllexport)
|
||||
# else
|
||||
# define PTW32_DLLPORT __declspec (dllimport)
|
||||
# endif
|
||||
#else
|
||||
# define PTW32_DLLPORT
|
||||
#endif
|
||||
|
||||
/*
|
||||
* This is a duplicate of what is in the autoconf config.h,
|
||||
* which is only used when building the pthread-win32 libraries.
|
||||
*/
|
||||
|
||||
#if !defined(PTW32_CONFIG_H)
|
||||
# if defined(WINCE)
|
||||
# define NEED_ERRNO
|
||||
# define NEED_SEM
|
||||
# endif
|
||||
# if defined(__MINGW64__)
|
||||
# define HAVE_STRUCT_TIMESPEC
|
||||
# define HAVE_MODE_T
|
||||
# elif defined(_UWIN) || defined(__MINGW32__)
|
||||
# define HAVE_MODE_T
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX
|
||||
#if defined(NEED_ERRNO)
|
||||
#include "need_errno.h"
|
||||
#else
|
||||
#include <errno.h>
|
||||
#endif
|
||||
#endif /* PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX */
|
||||
|
||||
#if (defined(__MINGW64__) || defined(__MINGW32__)) || defined(_UWIN)
|
||||
# if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX
|
||||
/* For pid_t */
|
||||
# include <sys/types.h>
|
||||
/* Required by Unix 98 */
|
||||
# include <time.h>
|
||||
# else
|
||||
typedef int pid_t;
|
||||
# endif
|
||||
#else
|
||||
typedef int pid_t;
|
||||
#endif
|
||||
|
||||
/* Thread scheduling policies */
|
||||
|
||||
enum {
|
||||
SCHED_OTHER = 0,
|
||||
SCHED_FIFO,
|
||||
SCHED_RR,
|
||||
SCHED_MIN = SCHED_OTHER,
|
||||
SCHED_MAX = SCHED_RR
|
||||
};
|
||||
|
||||
struct sched_param {
|
||||
int sched_priority;
|
||||
};
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C"
|
||||
{
|
||||
#endif /* __cplusplus */
|
||||
|
||||
PTW32_DLLPORT int __cdecl sched_yield (void);
|
||||
|
||||
PTW32_DLLPORT int __cdecl sched_get_priority_min (int policy);
|
||||
|
||||
PTW32_DLLPORT int __cdecl sched_get_priority_max (int policy);
|
||||
|
||||
PTW32_DLLPORT int __cdecl sched_setscheduler (pid_t pid, int policy);
|
||||
|
||||
PTW32_DLLPORT int __cdecl sched_getscheduler (pid_t pid);
|
||||
|
||||
/*
|
||||
* Note that this macro returns ENOTSUP rather than
|
||||
* ENOSYS as might be expected. However, returning ENOSYS
|
||||
* should mean that sched_get_priority_{min,max} are
|
||||
* not implemented as well as sched_rr_get_interval.
|
||||
* This is not the case, since we just don't support
|
||||
* round-robin scheduling. Therefore I have chosen to
|
||||
* return the same value as sched_setscheduler when
|
||||
* SCHED_RR is passed to it.
|
||||
*/
|
||||
#define sched_rr_get_interval(_pid, _interval) \
|
||||
( errno = ENOTSUP, (int) -1 )
|
||||
|
||||
|
||||
#if defined(__cplusplus)
|
||||
} /* End of extern "C" */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#undef PTW32_SCHED_LEVEL
|
||||
#undef PTW32_SCHED_LEVEL_MAX
|
||||
|
||||
#endif /* !_SCHED_H */
|
||||
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
/* Copyright (C) 2000 MySQL AB
|
||||
|
||||
This program 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
|
||||
#ifndef _typelib_h
|
||||
#define _typelib_h
|
||||
|
||||
typedef struct st_typelib { /* Different types saved here */
|
||||
unsigned int count; /* How many types */
|
||||
const char *name; /* Name of typelib */
|
||||
const char **type_names;
|
||||
unsigned int *type_lengths;
|
||||
} TYPELIB;
|
||||
|
||||
extern int find_type(char *x,TYPELIB *typelib,unsigned int full_name);
|
||||
extern void make_type(char *to,unsigned int nr,TYPELIB *typelib);
|
||||
extern const char *get_type(TYPELIB *typelib,unsigned int nr);
|
||||
|
||||
extern TYPELIB sql_protocol_typelib;
|
||||
|
||||
#endif /* _typelib_h */
|
||||
Vendored
BIN
Binary file not shown.
Vendored
BIN
Binary file not shown.
Reference in new issue
Block a user