diff options
81 files changed, 12918 insertions, 2223 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 6ac87be249b..d41cde72d04 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -108,18 +108,18 @@ SET(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -DDBUG_OFF") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4800 /wd4805") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4800 /wd4805") -IF(CMAKE_GENERATOR MATCHES "Visual Studio 8") +# Disable warnings in Visual Studio 8 and above +IF(MSVC AND NOT CMAKE_GENERATOR MATCHES "Visual Studio 7") SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /wd4996") SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /wd4996") SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /wd4996") SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /wd4996") SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /wd4996") SET(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} /wd4996") -ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 8") - -IF(CMAKE_GENERATOR MATCHES "Visual Studio 7" OR - CMAKE_GENERATOR MATCHES "Visual Studio 8") +ENDIF(MSVC AND NOT CMAKE_GENERATOR MATCHES "Visual Studio 7") +# Settings for Visual Studio 7 and above. +IF(MSVC) # replace /MDd with /MTd STRING(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE}) STRING(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELWITHDEBINFO ${CMAKE_C_FLAGS_RELWITHDEBINFO}) @@ -149,9 +149,7 @@ IF(CMAKE_GENERATOR MATCHES "Visual Studio 7" OR IF(NOT tmp_manifest) SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO") ENDIF(NOT tmp_manifest) - -ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 7" OR - CMAKE_GENERATOR MATCHES "Visual Studio 8") +ENDIF(MSVC) IF(WIN32) ADD_DEFINITIONS("-D_WINDOWS -D__WIN__ -D_CRT_SECURE_NO_DEPRECATE") diff --git a/Makefile.am b/Makefile.am index d7745d96e6c..c0a5334a032 100644 --- a/Makefile.am +++ b/Makefile.am @@ -59,6 +59,8 @@ dist-hook: --srcdir=$(top_srcdir) storage/myisam/myisamchk --silent --fast $(distdir)/win/data/mysql/*.MYI +all-local: @ABI_CHECK@ + tags: support-files/build-tags @@ -232,5 +234,81 @@ test-full-qa: test-binlog-statement test-ext test-fast-view \ test-fast-cursor test-unit +# +# Headers which need to be checked for abi/api compatibility. +# API_PREPROCESSOR_HEADER will be used until mysql_priv.h stablizes +# after which TEST_PREPROCESSOR_HEADER will be used. +# + +API_PREPROCESSOR_HEADER = $(top_srcdir)/include/mysql/plugin.h \ + $(top_srcdir)/include/mysql.h + +TEST_PREPROCESSOR_HEADER = $(top_srcdir)/include/mysql/plugin.h \ + $(top_srcdir)/sql/mysql_priv.h \ + $(top_srcdir)/include/mysql.h + +# +# Rules for checking that the abi/api has not changed. +# +# The following steps are followed in the do_abi_check rule below +# +# 1) Generate preprocessor output for the files that need to +# be tested for abi/api changes. use -nostdinc to prevent +# generation of preprocessor output for system headers. This +# results in messages in stderr saying that these headers +# were not found. Redirect the stderr output to /dev/null +# to prevent seeing these messages. +# 2) sed the output to +# 2.1) remove blank lines and lines that begin with "# " +# 2.2) When gcc -E is run on the Mac OS and solaris sparc platforms it +# introduces a line of output that shows up as a difference between +# the .pp and .out files. Remove these OS specific preprocessor text +# inserted by the preprocessor. +# 3) diff the generated file and the canons (.pp files already in +# the repository). +# 4) delete the .out file that is generated. +# +# If the diff fails, the generated file is not removed. This will +# be useful for analysis of ABI differences (e.g. using a visual +# diff tool). +# +# A ABI change that causes a build to fail will always be accompanied +# by new canons (.out files). The .out files that are not removed will +# be replaced as the new .pp files. +# +# e.g. If include/mysql/plugin.h has an ABI change then this rule would +# leave a <build directory>/abi_check.out file. +# +# A developer with a justified API change will then do a +# mv <build directory>/abi_check.out include/mysql/plugin.pp +# to replace the old canons with the new ones. +# + +abi_check: $(API_PREPROCESSOR_HEADER) + $(MAKE) abi_headers="$^" do_abi_check + +abi_check_all: $(TEST_PREPROCESSOR_HEADER) + $(MAKE) abi_headers="$^" do_abi_check + +do_abi_check: + set -ex; \ + for file in $(abi_headers); do \ + @CC@ -E -nostdinc -dI \ + -I$(top_srcdir)/include \ + -I$(top_srcdir)/include/mysql \ + -I$(top_srcdir)/sql \ + -I$(top_builddir)/include \ + -I$(top_builddir)/include/mysql \ + -I$(top_builddir)/sql \ + $$file 2>/dev/null | \ + @SED@ -e '/^# /d' \ + -e '/^[ ]*$$/d' \ + -e '/^#pragma GCC set_debug_pwd/d' \ + -e '/^#ident/d' > \ + $(top_builddir)/abi_check.out; \ + @DIFF@ -w $$file.pp $(top_builddir)/abi_check.out; \ + @RM@ $(top_builddir)/abi_check.out; \ + done + # Don't update the files from bitkeeper %::SCCS/s.% diff --git a/configure.in b/configure.in index 2b3eb883b8c..4483910526b 100644 --- a/configure.in +++ b/configure.in @@ -419,6 +419,7 @@ AC_PATH_PROG(SED, sed, sed) AC_PATH_PROG(CMP, cmp, cmp) AC_PATH_PROG(CHMOD, chmod, chmod) AC_PATH_PROG(HOSTNAME, hostname, hostname) +AC_PATH_PROG(DIFF, diff, diff) # Check for a GNU tar named 'gtar', or 'gnutar' (MacOS X) and # fall back to 'tar' otherwise and hope that it's a GNU tar as well AC_CHECK_PROGS(TAR, gnutar gtar tar) @@ -443,25 +444,16 @@ AC_SUBST(HOSTNAME) AC_SUBST(PERL) AC_SUBST(PERL5) -# icheck, used for ABI check -AC_PATH_PROG(ICHECK, icheck, no) -# "icheck" is also the name of a file system check program on Tru64. -# Verify the program found is really the interface checker. -if test "x$ICHECK" != "xno" +# Enable the abi_check rule only if gcc is available + +if expr "$CC" : ".*gcc.*" then - AC_MSG_CHECKING(if $ICHECK works as expected) - echo "int foo;" > conftest.h - $ICHECK --canonify -o conftest.ic conftest.h 2>/dev/null - if test -f "conftest.ic" - then - AC_MSG_RESULT(yes) - else - AC_MSG_RESULT(no) - ICHECK=no - fi - rm -f conftest.ic conftest.h + ABI_CHECK="abi_check" +else + ABI_CHECK="" fi -AC_SUBST(ICHECK) + +AC_SUBST(ABI_CHECK) # Lock for PS AC_PATH_PROG(PS, ps, ps) diff --git a/extra/yassl/Makefile.am b/extra/yassl/Makefile.am index 1c0e13c511a..ddd57d60a99 100644 --- a/extra/yassl/Makefile.am +++ b/extra/yassl/Makefile.am @@ -1,6 +1,5 @@ SUBDIRS = taocrypt src testsuite -EXTRA_DIST = yassl.dsp yassl.dsw yassl.vcproj \ - CMakeLists.txt +EXTRA_DIST = CMakeLists.txt # Don't update the files from bitkeeper %::SCCS/s.% diff --git a/extra/yassl/taocrypt/Makefile.am b/extra/yassl/taocrypt/Makefile.am index ac56cfdcf09..11fea2064f0 100644 --- a/extra/yassl/taocrypt/Makefile.am +++ b/extra/yassl/taocrypt/Makefile.am @@ -1,5 +1,5 @@ SUBDIRS = src test benchmark -EXTRA_DIST = taocrypt.dsw taocrypt.dsp taocrypt.vcproj CMakeLists.txt $(wildcard mySTL/*.hpp) +EXTRA_DIST = CMakeLists.txt $(wildcard mySTL/*.hpp) # Don't update the files from bitkeeper %::SCCS/s.% diff --git a/extra/yassl/taocrypt/taocrypt.vcproj b/extra/yassl/taocrypt/taocrypt.vcproj deleted file mode 100755 index bcbc0f82192..00000000000 --- a/extra/yassl/taocrypt/taocrypt.vcproj +++ /dev/null @@ -1,268 +0,0 @@ -<?xml version="1.0" encoding="Windows-1252"?> -<VisualStudioProject - ProjectType="Visual C++" - Version="7.10" - Name="taocrypt" - SccProjectName="" - SccLocalPath=""> - <Platforms> - <Platform - Name="Win32"/> - </Platforms> - <Configurations> - <Configuration - Name="Debug|Win32" - OutputDirectory=".\debug_obj" - IntermediateDirectory=".\debug_obj" - ConfigurationType="4" - UseOfMFC="0" - ATLMinimizesCRunTimeLibraryUsage="FALSE" - CharacterSet="2"> - <Tool - Name="VCCLCompilerTool" - Optimization="0" - OptimizeForProcessor="2" - AdditionalIncludeDirectories="include,mySTL" - PreprocessorDefinitions="WIN32;_DEBUG;_LIB" - ExceptionHandling="FALSE" - BasicRuntimeChecks="3" - RuntimeLibrary="1" - UsePrecompiledHeader="2" - PrecompiledHeaderFile=".\debug_obj/taocrypt.pch" - AssemblerListingLocation=".\debug_obj/" - ObjectFile=".\debug_obj/" - ProgramDataBaseFileName=".\debug_obj/" - BrowseInformation="1" - WarningLevel="3" - SuppressStartupBanner="TRUE" - DebugInformationFormat="4" - CompileAs="0"/> - <Tool - Name="VCCustomBuildTool"/> - <Tool - Name="VCLibrarianTool" - OutputFile=".\debug_obj\taocrypt.lib" - SuppressStartupBanner="TRUE"/> - <Tool - Name="VCMIDLTool"/> - <Tool - Name="VCPostBuildEventTool"/> - <Tool - Name="VCPreBuildEventTool"/> - <Tool - Name="VCPreLinkEventTool"/> - <Tool - Name="VCResourceCompilerTool" - PreprocessorDefinitions="_DEBUG" - Culture="1033"/> - <Tool - Name="VCWebServiceProxyGeneratorTool"/> - <Tool - Name="VCXMLDataGeneratorTool"/> - <Tool - Name="VCManagedWrapperGeneratorTool"/> - <Tool - Name="VCAuxiliaryManagedWrapperGeneratorTool"/> - </Configuration> - <Configuration - Name="Release|Win32" - OutputDirectory=".\release_obj" - IntermediateDirectory=".\release_obj" - ConfigurationType="4" - UseOfMFC="0" - ATLMinimizesCRunTimeLibraryUsage="FALSE" - CharacterSet="2"> - <Tool - Name="VCCLCompilerTool" - Optimization="2" - InlineFunctionExpansion="1" - OptimizeForProcessor="2" - AdditionalIncludeDirectories="include,mySTL" - PreprocessorDefinitions="WIN32;NDEBUG;_LIB" - StringPooling="TRUE" - ExceptionHandling="FALSE" - RuntimeLibrary="0" - EnableFunctionLevelLinking="TRUE" - UsePrecompiledHeader="2" - PrecompiledHeaderFile=".\release_obj/taocrypt.pch" - AssemblerListingLocation=".\release_obj/" - ObjectFile=".\release_obj/" - ProgramDataBaseFileName=".\release_obj/" - WarningLevel="3" - SuppressStartupBanner="TRUE" - CompileAs="0"/> - <Tool - Name="VCCustomBuildTool"/> - <Tool - Name="VCLibrarianTool" - OutputFile=".\release_obj\taocrypt.lib" - SuppressStartupBanner="TRUE"/> - <Tool - Name="VCMIDLTool"/> - <Tool - Name="VCPostBuildEventTool"/> - <Tool - Name="VCPreBuildEventTool"/> - <Tool - Name="VCPreLinkEventTool"/> - <Tool - Name="VCResourceCompilerTool" - PreprocessorDefinitions="NDEBUG" - Culture="1033"/> - <Tool - Name="VCWebServiceProxyGeneratorTool"/> - <Tool - Name="VCXMLDataGeneratorTool"/> - <Tool - Name="VCManagedWrapperGeneratorTool"/> - <Tool - Name="VCAuxiliaryManagedWrapperGeneratorTool"/> - </Configuration> - </Configurations> - <References> - </References> - <Files> - <Filter - Name="Source Files" - Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"> - <File - RelativePath="src\aes.cpp"> - </File> - <File - RelativePath="src\aestables.cpp"> - </File> - <File - RelativePath="src\algebra.cpp"> - </File> - <File - RelativePath="src\arc4.cpp"> - </File> - <File - RelativePath="src\asn.cpp"> - </File> - <File - RelativePath="src\coding.cpp"> - </File> - <File - RelativePath="src\des.cpp"> - </File> - <File - RelativePath="src\dh.cpp"> - </File> - <File - RelativePath="src\dsa.cpp"> - </File> - <File - RelativePath="src\file.cpp"> - </File> - <File - RelativePath="src\hash.cpp"> - </File> - <File - RelativePath="src\integer.cpp"> - </File> - <File - RelativePath="src\md2.cpp"> - </File> - <File - RelativePath="src\md4.cpp"> - </File> - <File - RelativePath="src\md5.cpp"> - </File> - <File - RelativePath="src\misc.cpp"> - </File> - <File - RelativePath="src\random.cpp"> - </File> - <File - RelativePath="src\ripemd.cpp"> - </File> - <File - RelativePath="src\rsa.cpp"> - </File> - <File - RelativePath="src\sha.cpp"> - </File> - </Filter> - <Filter - Name="Header Files" - Filter="h;hpp;hxx;hm;inl"> - <File - RelativePath="include\aes.hpp"> - </File> - <File - RelativePath="include\algebra.hpp"> - </File> - <File - RelativePath="include\arc4.hpp"> - </File> - <File - RelativePath="include\asn.hpp"> - </File> - <File - RelativePath="include\block.hpp"> - </File> - <File - RelativePath="include\coding.hpp"> - </File> - <File - RelativePath="include\des.hpp"> - </File> - <File - RelativePath="include\dh.hpp"> - </File> - <File - RelativePath="include\dsa.hpp"> - </File> - <File - RelativePath="include\error.hpp"> - </File> - <File - RelativePath="include\file.hpp"> - </File> - <File - RelativePath="include\hash.hpp"> - </File> - <File - RelativePath="include\hmac.hpp"> - </File> - <File - RelativePath="include\integer.hpp"> - </File> - <File - RelativePath="include\md2.hpp"> - </File> - <File - RelativePath="include\md4.hpp"> - </File> - <File - RelativePath="include\md5.hpp"> - </File> - <File - RelativePath="include\misc.hpp"> - </File> - <File - RelativePath="include\modarith.hpp"> - </File> - <File - RelativePath="include\modes.hpp"> - </File> - <File - RelativePath="include\random.hpp"> - </File> - <File - RelativePath="include\ripemd.hpp"> - </File> - <File - RelativePath="include\rsa.hpp"> - </File> - <File - RelativePath="include\sha.hpp"> - </File> - </Filter> - </Files> - <Globals> - </Globals> -</VisualStudioProject> diff --git a/extra/yassl/yassl.vcproj b/extra/yassl/yassl.vcproj deleted file mode 100755 index bc020747096..00000000000 --- a/extra/yassl/yassl.vcproj +++ /dev/null @@ -1,211 +0,0 @@ -<?xml version="1.0" encoding="Windows-1252"?> -<VisualStudioProject - ProjectType="Visual C++" - Version="7.10" - Name="yassl" - SccProjectName="" - SccLocalPath=""> - <Platforms> - <Platform - Name="Win32"/> - </Platforms> - <Configurations> - <Configuration - Name="Debug|Win32" - OutputDirectory=".\debug_obj" - IntermediateDirectory=".\debug_obj" - ConfigurationType="4" - UseOfMFC="0" - ATLMinimizesCRunTimeLibraryUsage="FALSE" - CharacterSet="2"> - <Tool - Name="VCCLCompilerTool" - Optimization="0" - OptimizeForProcessor="2" - AdditionalIncludeDirectories="include,taocrypt\include,taocrypt\mySTL" - PreprocessorDefinitions="WIN32;_DEBUG;_LIB;YASSL_PREFIX" - ExceptionHandling="FALSE" - BasicRuntimeChecks="3" - RuntimeLibrary="1" - UsePrecompiledHeader="2" - PrecompiledHeaderFile=".\debug_obj/yassl.pch" - AssemblerListingLocation=".\debug_obj/" - ObjectFile=".\debug_obj/" - ProgramDataBaseFileName=".\debug_obj/" - BrowseInformation="1" - WarningLevel="3" - SuppressStartupBanner="TRUE" - DebugInformationFormat="4" - CompileAs="0"/> - <Tool - Name="VCCustomBuildTool"/> - <Tool - Name="VCLibrarianTool" - OutputFile=".\debug_obj\yassl.lib" - SuppressStartupBanner="TRUE"/> - <Tool - Name="VCMIDLTool"/> - <Tool - Name="VCPostBuildEventTool"/> - <Tool - Name="VCPreBuildEventTool"/> - <Tool - Name="VCPreLinkEventTool"/> - <Tool - Name="VCResourceCompilerTool" - PreprocessorDefinitions="_DEBUG" - Culture="1033"/> - <Tool - Name="VCWebServiceProxyGeneratorTool"/> - <Tool - Name="VCXMLDataGeneratorTool"/> - <Tool - Name="VCManagedWrapperGeneratorTool"/> - <Tool - Name="VCAuxiliaryManagedWrapperGeneratorTool"/> - </Configuration> - <Configuration - Name="Release|Win32" - OutputDirectory=".\release_obj" - IntermediateDirectory=".\release_obj" - ConfigurationType="4" - UseOfMFC="0" - ATLMinimizesCRunTimeLibraryUsage="FALSE" - CharacterSet="2"> - <Tool - Name="VCCLCompilerTool" - Optimization="2" - InlineFunctionExpansion="1" - OptimizeForProcessor="2" - AdditionalIncludeDirectories="include,taocrypt\include,taocrypt\mySTL" - PreprocessorDefinitions="WIN32;NDEBUG;_LIB;YASSL_PREFIX" - StringPooling="TRUE" - ExceptionHandling="FALSE" - RuntimeLibrary="0" - EnableFunctionLevelLinking="TRUE" - UsePrecompiledHeader="2" - PrecompiledHeaderFile=".\release_obj/yassl.pch" - AssemblerListingLocation=".\release_obj/" - ObjectFile=".\release_obj/" - ProgramDataBaseFileName=".\release_obj/" - WarningLevel="3" - SuppressStartupBanner="TRUE" - CompileAs="0"/> - <Tool - Name="VCCustomBuildTool"/> - <Tool - Name="VCLibrarianTool" - OutputFile=".\release_obj\yassl.lib" - SuppressStartupBanner="TRUE"/> - <Tool - Name="VCMIDLTool"/> - <Tool - Name="VCPostBuildEventTool"/> - <Tool - Name="VCPreBuildEventTool"/> - <Tool - Name="VCPreLinkEventTool"/> - <Tool - Name="VCResourceCompilerTool" - PreprocessorDefinitions="NDEBUG" - Culture="1033"/> - <Tool - Name="VCWebServiceProxyGeneratorTool"/> - <Tool - Name="VCXMLDataGeneratorTool"/> - <Tool - Name="VCManagedWrapperGeneratorTool"/> - <Tool - Name="VCAuxiliaryManagedWrapperGeneratorTool"/> - </Configuration> - </Configurations> - <References> - </References> - <Files> - <Filter - Name="Source Files" - Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"> - <File - RelativePath="src\buffer.cpp"> - </File> - <File - RelativePath="src\cert_wrapper.cpp"> - </File> - <File - RelativePath="src\crypto_wrapper.cpp"> - </File> - <File - RelativePath="src\handshake.cpp"> - </File> - <File - RelativePath="src\lock.cpp"> - </File> - <File - RelativePath="src\log.cpp"> - </File> - <File - RelativePath="src\socket_wrapper.cpp"> - </File> - <File - RelativePath="src\ssl.cpp"> - </File> - <File - RelativePath="src\timer.cpp"> - </File> - <File - RelativePath="src\yassl_error.cpp"> - </File> - <File - RelativePath="src\yassl_imp.cpp"> - </File> - <File - RelativePath="src\yassl_int.cpp"> - </File> - </Filter> - <Filter - Name="Header Files" - Filter="h;hpp;hxx;hm;inl"> - <File - RelativePath="include\buffer.hpp"> - </File> - <File - RelativePath="include\cert_wrapper.hpp"> - </File> - <File - RelativePath="include\crypto_wrapper.hpp"> - </File> - <File - RelativePath="include\factory.hpp"> - </File> - <File - RelativePath="include\handshake.hpp"> - </File> - <File - RelativePath="include\lock.hpp"> - </File> - <File - RelativePath="include\log.hpp"> - </File> - <File - RelativePath="include\socket_wrapper.hpp"> - </File> - <File - RelativePath="include\timer.hpp"> - </File> - <File - RelativePath="include\yassl_error.hpp"> - </File> - <File - RelativePath="include\yassl_imp.hpp"> - </File> - <File - RelativePath="include\yassl_int.hpp"> - </File> - <File - RelativePath="include\yassl_types.hpp"> - </File> - </Filter> - </Files> - <Globals> - </Globals> -</VisualStudioProject> diff --git a/include/Makefile.am b/include/Makefile.am index f04afa06cb1..9438f0d0f25 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -38,10 +38,11 @@ noinst_HEADERS = config-win.h config-netware.h my_bit.h \ atomic/rwlock.h atomic/x86-gcc.h atomic/x86-msvc.h \ atomic/gcc_builtins.h my_libwrap.h my_stacktrace.h +EXTRA_DIST = mysql.h.pp mysql/plugin.h.pp + # Remove built files and the symlinked directories CLEANFILES = $(BUILT_SOURCES) readline openssl -EXTRA_DIST = mysql_h.ic # Some include files that may be moved and patched by configure DISTCLEANFILES = sched.h $(CLEANFILES) @@ -63,18 +64,5 @@ my_config.h: config.h dist-hook: $(RM) -f $(distdir)/mysql_version.h $(distdir)/my_config.h -# -# Rules for checking that ABI has not changed -# - -# Create a icheck file and compare it to the reference -abi_check: $(HEADERS_ABI) mysql_version.h mysql_h.ic - @set -ex; \ - if [ @ICHECK@ != no ] ; then \ - @ICHECK@ --canonify --skip-from-re /usr/ -o $@ $(HEADERS_ABI); \ - @ICHECK@ --compare mysql_h.ic $@; \ - fi; \ - touch abi_check; - # Don't update the files from bitkeeper %::SCCS/s.% diff --git a/include/mysql.h.pp b/include/mysql.h.pp new file mode 100644 index 00000000000..633cde41130 --- /dev/null +++ b/include/mysql.h.pp @@ -0,0 +1,674 @@ +#include <sys/types.h> +typedef char my_bool; +typedef int my_socket; +#include "mysql_version.h" +#include "mysql_com.h" +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, COM_DAEMON, + COM_END +}; +struct st_vio; +typedef struct st_vio Vio; +typedef struct st_net { + Vio *vio; + unsigned char *buff,*buff_end,*write_pos,*read_pos; + my_socket fd; + unsigned long remain_in_buf,length, buf_length, where_b; + unsigned long max_packet,max_packet_size; + unsigned int pkt_nr,compress_pkt_nr; + unsigned int write_timeout, read_timeout, retry_count; + int fcntl; + unsigned int *return_status; + unsigned char reading_or_writing; + char save_char; + my_bool unused0; + my_bool unused; + my_bool compress; + my_bool unused1; + unsigned char *query_cache_query; + unsigned int last_errno; + unsigned char error; + my_bool unused2; + my_bool return_errno; + char last_error[512]; + char sqlstate[5 +1]; + void *extension; +} NET; +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 +}; +enum mysql_enum_shutdown_level { + SHUTDOWN_DEFAULT = 0, + SHUTDOWN_WAIT_CONNECTIONS= (unsigned char)(1 << 0), + SHUTDOWN_WAIT_TRANSACTIONS= (unsigned char)(1 << 1), + SHUTDOWN_WAIT_UPDATES= (unsigned char)(1 << 3), + SHUTDOWN_WAIT_ALL_BUFFERS= ((unsigned char)(1 << 3) << 1), + SHUTDOWN_WAIT_CRITICAL_BUFFERS= ((unsigned char)(1 << 3) << 1) + 1, + KILL_QUERY= 254, + 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 +}; +enum enum_mysql_set_option +{ + MYSQL_OPTION_MULTI_STATEMENTS_ON, + MYSQL_OPTION_MULTI_STATEMENTS_OFF +}; +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 clear_buffer); +my_bool net_realloc(NET *net, size_t length); +my_bool net_flush(NET *net); +my_bool my_net_write(NET *net,const unsigned char *packet, size_t len); +my_bool net_write_command(NET *net,unsigned char command, + const unsigned char *header, size_t head_len, + const unsigned char *packet, size_t len); +int net_real_write(NET *net,const unsigned char *packet, size_t len); +unsigned long my_net_read(NET *net); +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; +}; +enum Item_result {STRING_RESULT=0, REAL_RESULT, INT_RESULT, ROW_RESULT, + DECIMAL_RESULT}; +typedef struct st_udf_args +{ + unsigned int arg_count; + enum Item_result *arg_type; + char **args; + unsigned long *lengths; + char *maybe_null; + char **attributes; + unsigned long *attribute_lengths; + void *extension; +} UDF_ARGS; +typedef struct st_udf_init +{ + my_bool maybe_null; + unsigned int decimals; + unsigned long max_length; + char *ptr; + my_bool const_item; + void *extension; +} UDF_INIT; +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); +char *get_tty_password(const char *opt_message); +const char *mysql_errno_to_sqlstate(unsigned int mysql_errno); +my_bool my_thread_init(void); +void my_thread_end(void); +#include "mysql_time.h" +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 +}; +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; +#include "my_list.h" +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,unsigned char * argument); +extern unsigned int mysql_port; +extern char *mysql_unix_port; +typedef struct st_mysql_field { + char *name; + char *org_name; + char *table; + char *org_table; + char *db; + char *catalog; + char *def; + unsigned long length; + unsigned long max_length; + 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; + unsigned int decimals; + unsigned int charsetnr; + enum enum_field_types type; + void *extension; +} MYSQL_FIELD; +typedef char **MYSQL_ROW; +typedef unsigned int MYSQL_FIELD_OFFSET; +typedef unsigned long long my_ulonglong; +#include "typelib.h" +#include "my_alloc.h" +typedef struct st_used_mem +{ + struct st_used_mem *next; + unsigned int left; + unsigned int size; +} USED_MEM; +typedef struct st_mem_root +{ + USED_MEM *free; + USED_MEM *used; + USED_MEM *pre_alloc; + size_t min_malloc; + size_t block_size; + unsigned int block_num; + unsigned int first_block_usage; + void (*error_handler)(void); +} MEM_ROOT; +typedef struct st_typelib { + unsigned int count; + const char *name; + const char **type_names; + unsigned int *type_lengths; +} TYPELIB; +extern my_ulonglong find_typeset(char *x, TYPELIB *typelib,int *error_position); +extern int find_type_or_exit(const char *x, TYPELIB *typelib, + const char *option); +extern int find_type(char *x, const 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 *copy_typelib(MEM_ROOT *root, TYPELIB *from); +extern TYPELIB sql_protocol_typelib; +typedef struct st_mysql_rows { + struct st_mysql_rows *next; + MYSQL_ROW data; + unsigned long length; +} MYSQL_ROWS; +typedef MYSQL_ROWS *MYSQL_ROW_OFFSET; +#include "my_alloc.h" +typedef struct embedded_query_result EMBEDDED_QUERY_RESULT; +typedef struct st_mysql_data { + MYSQL_ROWS *data; + struct embedded_query_result *embedded_info; + MEM_ROOT alloc; + my_ulonglong rows; + unsigned int fields; + void *extension; +} 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, + MYSQL_OPT_SSL_VERIFY_SERVER_CERT +}; +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; + char *ssl_cert; + char *ssl_ca; + char *ssl_capath; + char *ssl_cipher; + char *shared_memory_base_name; + unsigned long max_allowed_packet; + my_bool use_ssl; + my_bool compress,named_pipe; + my_bool rpl_probe; + my_bool rpl_parse; + my_bool no_master_reads; + my_bool separate_thread; + enum mysql_option methods_to_use; + char *client_ip; + my_bool secure_auth; + my_bool report_data_truncation; + 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; + void *extension; +}; +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 +}; +enum mysql_rpl_type +{ + MYSQL_RPL_MASTER, MYSQL_RPL_SLAVE, MYSQL_RPL_ADMIN +}; +typedef struct character_set +{ + unsigned int number; + unsigned int state; + const char *csname; + const char *name; + const char *comment; + const char *dir; + unsigned int mbminlen; + unsigned int mbmaxlen; +} MY_CHARSET_INFO; +struct st_mysql_methods; +struct st_mysql_stmt; +typedef struct st_mysql +{ + NET net; + unsigned char *connector_fd; + char *host,*user,*passwd,*unix_socket,*server_version,*host_info; + char *info, *db; + struct charset_info_st *charset; + MYSQL_FIELD *fields; + MEM_ROOT field_alloc; + my_ulonglong affected_rows; + my_ulonglong insert_id; + my_ulonglong extra_info; + unsigned long thread_id; + 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; + my_bool reconnect; + char scramble[20 +1]; + my_bool rpl_pivot; + struct st_mysql* master, *next_slave; + struct st_mysql* last_used_slave; + struct st_mysql* last_used_con; + LIST *stmts; + const struct st_mysql_methods *methods; + void *thd; + my_bool *unbuffered_fetch_owner; + char *info_buffer; + void *extension; +} MYSQL; +typedef struct st_mysql_res { + my_ulonglong row_count; + MYSQL_FIELD *fields; + MYSQL_DATA *data; + MYSQL_ROWS *data_cursor; + unsigned long *lengths; + MYSQL *handle; + const struct st_mysql_methods *methods; + MYSQL_ROW row; + MYSQL_ROW current_row; + MEM_ROOT field_alloc; + unsigned int field_count, current_field; + my_bool eof; + my_bool unbuffered_fetch_cancelled; + void *extension; +} MYSQL_RES; +typedef struct st_mysql_manager +{ + NET net; + char *host, *user, *passwd; + char *net_buf, *net_buf_pos, *net_data_end; + unsigned int port; + int cmd_status; + int last_errno; + int net_buf_size; + my_bool free_me; + my_bool eof; + char last_error[256]; + void *extension; +} MYSQL_MANAGER; +typedef struct st_mysql_parameters +{ + unsigned long *p_max_allowed_packet; + unsigned long *p_net_buffer_length; + void *extension; +} MYSQL_PARAMETERS; +int mysql_server_init(int argc, char **argv, char **groups); +void mysql_server_end(void); +MYSQL_PARAMETERS * mysql_get_parameters(void); +my_bool mysql_thread_init(void); +void mysql_thread_end(void); +my_ulonglong mysql_num_rows(MYSQL_RES *res); +unsigned int mysql_num_fields(MYSQL_RES *res); +my_bool mysql_eof(MYSQL_RES *res); +MYSQL_FIELD * mysql_fetch_field_direct(MYSQL_RES *res, + unsigned int fieldnr); +MYSQL_FIELD * mysql_fetch_fields(MYSQL_RES *res); +MYSQL_ROW_OFFSET mysql_row_tell(MYSQL_RES *res); +MYSQL_FIELD_OFFSET mysql_field_tell(MYSQL_RES *res); +unsigned int mysql_field_count(MYSQL *mysql); +my_ulonglong mysql_affected_rows(MYSQL *mysql); +my_ulonglong mysql_insert_id(MYSQL *mysql); +unsigned int mysql_errno(MYSQL *mysql); +const char * mysql_error(MYSQL *mysql); +const char * mysql_sqlstate(MYSQL *mysql); +unsigned int mysql_warning_count(MYSQL *mysql); +const char * mysql_info(MYSQL *mysql); +unsigned long mysql_thread_id(MYSQL *mysql); +const char * mysql_character_set_name(MYSQL *mysql); +int mysql_set_character_set(MYSQL *mysql, const char *csname); +MYSQL * mysql_init(MYSQL *mysql); +my_bool mysql_ssl_set(MYSQL *mysql, const char *key, + const char *cert, const char *ca, + const char *capath, const char *cipher); +const char * mysql_get_ssl_cipher(MYSQL *mysql); +my_bool mysql_change_user(MYSQL *mysql, const char *user, + const char *passwd, const char *db); +MYSQL * 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 mysql_select_db(MYSQL *mysql, const char *db); +int mysql_query(MYSQL *mysql, const char *q); +int mysql_send_query(MYSQL *mysql, const char *q, + unsigned long length); +int mysql_real_query(MYSQL *mysql, const char *q, + unsigned long length); +MYSQL_RES * mysql_store_result(MYSQL *mysql); +MYSQL_RES * mysql_use_result(MYSQL *mysql); +my_bool mysql_master_query(MYSQL *mysql, const char *q, + unsigned long length); +my_bool mysql_master_send_query(MYSQL *mysql, const char *q, + unsigned long length); +my_bool mysql_slave_query(MYSQL *mysql, const char *q, + unsigned long length); +my_bool mysql_slave_send_query(MYSQL *mysql, const char *q, + unsigned long length); +void mysql_get_character_set_info(MYSQL *mysql, + MY_CHARSET_INFO *charset); +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); +void mysql_enable_rpl_parse(MYSQL* mysql); +void mysql_disable_rpl_parse(MYSQL* mysql); +int mysql_rpl_parse_enabled(MYSQL* mysql); +void mysql_enable_reads_from_master(MYSQL* mysql); +void mysql_disable_reads_from_master(MYSQL* mysql); +my_bool mysql_reads_from_master_enabled(MYSQL* mysql); +enum mysql_rpl_type mysql_rpl_query_type(const char* q, int len); +my_bool mysql_rpl_probe(MYSQL* mysql); +int mysql_set_master(MYSQL* mysql, const char* host, + unsigned int port, + const char* user, + const char* passwd); +int mysql_add_slave(MYSQL* mysql, const char* host, + unsigned int port, + const char* user, + const char* passwd); +int mysql_shutdown(MYSQL *mysql, + enum mysql_enum_shutdown_level + shutdown_level); +int mysql_dump_debug_info(MYSQL *mysql); +int mysql_refresh(MYSQL *mysql, + unsigned int refresh_options); +int mysql_kill(MYSQL *mysql,unsigned long pid); +int mysql_set_server_option(MYSQL *mysql, + enum enum_mysql_set_option + option); +int mysql_ping(MYSQL *mysql); +const char * mysql_stat(MYSQL *mysql); +const char * mysql_get_server_info(MYSQL *mysql); +const char * mysql_get_client_info(void); +unsigned long mysql_get_client_version(void); +const char * mysql_get_host_info(MYSQL *mysql); +unsigned long mysql_get_server_version(MYSQL *mysql); +unsigned int mysql_get_proto_info(MYSQL *mysql); +MYSQL_RES * mysql_list_dbs(MYSQL *mysql,const char *wild); +MYSQL_RES * mysql_list_tables(MYSQL *mysql,const char *wild); +MYSQL_RES * mysql_list_processes(MYSQL *mysql); +int mysql_options(MYSQL *mysql,enum mysql_option option, + const void *arg); +void mysql_free_result(MYSQL_RES *result); +void mysql_data_seek(MYSQL_RES *result, + my_ulonglong offset); +MYSQL_ROW_OFFSET mysql_row_seek(MYSQL_RES *result, + MYSQL_ROW_OFFSET offset); +MYSQL_FIELD_OFFSET mysql_field_seek(MYSQL_RES *result, + MYSQL_FIELD_OFFSET offset); +MYSQL_ROW mysql_fetch_row(MYSQL_RES *result); +unsigned long * mysql_fetch_lengths(MYSQL_RES *result); +MYSQL_FIELD * mysql_fetch_field(MYSQL_RES *result); +MYSQL_RES * mysql_list_fields(MYSQL *mysql, const char *table, + const char *wild); +unsigned long mysql_escape_string(char *to,const char *from, + unsigned long from_length); +unsigned long mysql_hex_string(char *to,const char *from, + unsigned long from_length); +unsigned long mysql_real_escape_string(MYSQL *mysql, + char *to,const char *from, + unsigned long length); +void mysql_debug(const char *debug); +void myodbc_remove_escape(MYSQL *mysql,char *name); +unsigned int mysql_thread_safe(void); +my_bool mysql_embedded(void); +MYSQL_MANAGER* mysql_manager_init(MYSQL_MANAGER* con); +MYSQL_MANAGER* mysql_manager_connect(MYSQL_MANAGER* con, + const char* host, + const char* user, + const char* passwd, + unsigned int port); +void mysql_manager_close(MYSQL_MANAGER* con); +int mysql_manager_command(MYSQL_MANAGER* con, + const char* cmd, int cmd_len); +int mysql_manager_fetch_line(MYSQL_MANAGER* con, + char* res_buf, + int res_buf_size); +my_bool mysql_read_query_result(MYSQL *mysql); +enum enum_mysql_stmt_state +{ + MYSQL_STMT_INIT_DONE= 1, MYSQL_STMT_PREPARE_DONE, MYSQL_STMT_EXECUTE_DONE, + MYSQL_STMT_FETCH_DONE +}; +typedef struct st_mysql_bind +{ + unsigned long *length; + my_bool *is_null; + void *buffer; + my_bool *error; + unsigned char *row_ptr; + 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); + unsigned long buffer_length; + unsigned long offset; + unsigned long length_value; + unsigned int param_number; + unsigned int pack_length; + enum enum_field_types buffer_type; + my_bool error_value; + my_bool is_unsigned; + my_bool long_data_used; + my_bool is_null_value; + void *extension; +} MYSQL_BIND; +typedef struct st_mysql_stmt +{ + MEM_ROOT mem_root; + LIST list; + MYSQL *mysql; + MYSQL_BIND *params; + MYSQL_BIND *bind; + MYSQL_FIELD *fields; + MYSQL_DATA result; + MYSQL_ROWS *data_cursor; + int (*read_row_func)(struct st_mysql_stmt *stmt, + unsigned char **row); + my_ulonglong affected_rows; + my_ulonglong insert_id; + unsigned long stmt_id; + unsigned long flags; + unsigned long prefetch_rows; + unsigned int server_status; + unsigned int last_errno; + unsigned int param_count; + unsigned int field_count; + enum enum_mysql_stmt_state state; + char last_error[512]; + char sqlstate[5 +1]; + my_bool send_types_to_server; + my_bool bind_param_done; + unsigned char bind_result_done; + my_bool unbuffered_fetch_cancelled; + my_bool update_max_length; + void *extension; +} MYSQL_STMT; +enum enum_stmt_attr_type +{ + STMT_ATTR_UPDATE_MAX_LENGTH, + STMT_ATTR_CURSOR_TYPE, + 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 unsigned char *header, + unsigned long header_length, + const unsigned char *arg, + unsigned long arg_length, + my_bool skip_check, + MYSQL_STMT *stmt); + 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); + 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); + int (*read_rows_from_cursor)(MYSQL_STMT *stmt); +} MYSQL_METHODS; +MYSQL_STMT * mysql_stmt_init(MYSQL *mysql); +int mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, + unsigned long length); +int mysql_stmt_execute(MYSQL_STMT *stmt); +int mysql_stmt_fetch(MYSQL_STMT *stmt); +int mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind_arg, + unsigned int column, + unsigned long offset); +int mysql_stmt_store_result(MYSQL_STMT *stmt); +unsigned long mysql_stmt_param_count(MYSQL_STMT * stmt); +my_bool mysql_stmt_attr_set(MYSQL_STMT *stmt, + enum enum_stmt_attr_type attr_type, + const void *attr); +my_bool mysql_stmt_attr_get(MYSQL_STMT *stmt, + enum enum_stmt_attr_type attr_type, + void *attr); +my_bool mysql_stmt_bind_param(MYSQL_STMT * stmt, MYSQL_BIND * bnd); +my_bool mysql_stmt_bind_result(MYSQL_STMT * stmt, MYSQL_BIND * bnd); +my_bool mysql_stmt_close(MYSQL_STMT * stmt); +my_bool mysql_stmt_reset(MYSQL_STMT * stmt); +my_bool mysql_stmt_free_result(MYSQL_STMT *stmt); +my_bool mysql_stmt_send_long_data(MYSQL_STMT *stmt, + unsigned int param_number, + const char *data, + unsigned long length); +MYSQL_RES * mysql_stmt_result_metadata(MYSQL_STMT *stmt); +MYSQL_RES * mysql_stmt_param_metadata(MYSQL_STMT *stmt); +unsigned int mysql_stmt_errno(MYSQL_STMT * stmt); +const char * mysql_stmt_error(MYSQL_STMT * stmt); +const char * mysql_stmt_sqlstate(MYSQL_STMT * stmt); +MYSQL_ROW_OFFSET mysql_stmt_row_seek(MYSQL_STMT *stmt, + MYSQL_ROW_OFFSET offset); +MYSQL_ROW_OFFSET mysql_stmt_row_tell(MYSQL_STMT *stmt); +void mysql_stmt_data_seek(MYSQL_STMT *stmt, my_ulonglong offset); +my_ulonglong mysql_stmt_num_rows(MYSQL_STMT *stmt); +my_ulonglong mysql_stmt_affected_rows(MYSQL_STMT *stmt); +my_ulonglong mysql_stmt_insert_id(MYSQL_STMT *stmt); +unsigned int mysql_stmt_field_count(MYSQL_STMT *stmt); +my_bool mysql_commit(MYSQL * mysql); +my_bool mysql_rollback(MYSQL * mysql); +my_bool mysql_autocommit(MYSQL * mysql, my_bool auto_mode); +my_bool mysql_more_results(MYSQL *mysql); +int mysql_next_result(MYSQL *mysql); +void mysql_close(MYSQL *sock); diff --git a/include/mysql/plugin.h.pp b/include/mysql/plugin.h.pp new file mode 100644 index 00000000000..50511f515ab --- /dev/null +++ b/include/mysql/plugin.h.pp @@ -0,0 +1,139 @@ +struct st_mysql_lex_string +{ + char *str; + unsigned int length; +}; +typedef struct st_mysql_lex_string MYSQL_LEX_STRING; +struct st_mysql_xid { + long formatID; + long gtrid_length; + long bqual_length; + char data[128]; +}; +typedef struct st_mysql_xid MYSQL_XID; +enum enum_mysql_show_type +{ + SHOW_UNDEF, SHOW_BOOL, SHOW_INT, SHOW_LONG, + SHOW_LONGLONG, SHOW_CHAR, SHOW_CHAR_PTR, + SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE +}; +struct st_mysql_show_var { + const char *name; + char *value; + enum enum_mysql_show_type type; +}; +typedef int (*mysql_show_var_func)(void*, struct st_mysql_show_var*, char *); +struct st_mysql_sys_var; +struct st_mysql_value; +typedef int (*mysql_var_check_func)(void* thd, + struct st_mysql_sys_var *var, + void *save, struct st_mysql_value *value); +typedef void (*mysql_var_update_func)(void* thd, + struct st_mysql_sys_var *var, + void *var_ptr, const void *save); +struct st_mysql_plugin +{ + int type; + void *info; + const char *name; + const char *author; + const char *descr; + int license; + int (*init)(void *); + int (*deinit)(void *); + unsigned int version; + struct st_mysql_show_var *status_vars; + struct st_mysql_sys_var **system_vars; + void * __reserved1; +}; +enum enum_ftparser_mode +{ + MYSQL_FTPARSER_SIMPLE_MODE= 0, + MYSQL_FTPARSER_WITH_STOPWORDS= 1, + MYSQL_FTPARSER_FULL_BOOLEAN_INFO= 2 +}; +enum enum_ft_token_type +{ + FT_TOKEN_EOF= 0, + FT_TOKEN_WORD= 1, + FT_TOKEN_LEFT_PAREN= 2, + FT_TOKEN_RIGHT_PAREN= 3, + FT_TOKEN_STOPWORD= 4 +}; +typedef struct st_mysql_ftparser_boolean_info +{ + enum enum_ft_token_type type; + int yesno; + int weight_adjust; + char wasign; + char trunc; + char prev; + char *quot; +} MYSQL_FTPARSER_BOOLEAN_INFO; +typedef struct st_mysql_ftparser_param +{ + int (*mysql_parse)(struct st_mysql_ftparser_param *, + char *doc, int doc_len); + int (*mysql_add_word)(struct st_mysql_ftparser_param *, + char *word, int word_len, + MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info); + void *ftparser_state; + void *mysql_ftparam; + struct charset_info_st *cs; + char *doc; + int length; + int flags; + enum enum_ftparser_mode mode; +} MYSQL_FTPARSER_PARAM; +struct st_mysql_ftparser +{ + int interface_version; + int (*parse)(MYSQL_FTPARSER_PARAM *param); + int (*init)(MYSQL_FTPARSER_PARAM *param); + int (*deinit)(MYSQL_FTPARSER_PARAM *param); +}; +struct st_mysql_storage_engine +{ + int interface_version; +}; +struct handlerton; +struct st_mysql_daemon +{ + int interface_version; +}; +struct st_mysql_information_schema +{ + int interface_version; +}; +struct st_mysql_value +{ + int (*value_type)(struct st_mysql_value *); + const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length); + int (*val_real)(struct st_mysql_value *, double *realbuf); + int (*val_int)(struct st_mysql_value *, long long *intbuf); +}; +int thd_in_lock_tables(const void* thd); +int thd_tablespace_op(const void* thd); +long long thd_test_options(const void* thd, long long test_options); +int thd_sql_command(const void* thd); +const char *thd_proc_info(void* thd, const char *info); +void **thd_ha_data(const void* thd, const struct handlerton *hton); +int thd_tx_isolation(const void* thd); +char *thd_security_context(void* thd, char *buffer, unsigned int length, + unsigned int max_query_len); +void thd_inc_row_count(void* thd); +int mysql_tmpfile(const char *prefix); +int thd_killed(const void* thd); +unsigned long thd_get_thread_id(const void* thd); +void *thd_alloc(void* thd, unsigned int size); +void *thd_calloc(void* thd, unsigned int size); +char *thd_strdup(void* thd, const char *str); +char *thd_strmake(void* thd, const char *str, unsigned int size); +void *thd_memdup(void* thd, const void* str, unsigned int size); +MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str, + const char *str, unsigned int size, + int allocate_lex_string); +void thd_get_xid(const void* thd, MYSQL_XID *xid); +void mysql_query_cache_invalidate4(void* thd, + const char *key, unsigned int key_length, + int using_trx); diff --git a/include/mysql_h.ic b/include/mysql_h.ic deleted file mode 100644 index 832678a106b..00000000000 --- a/include/mysql_h.ic +++ /dev/null @@ -1,1166 +0,0 @@ -struct character_set; -struct rand_struct; -struct st_list; -struct st_mem_root; -struct st_mysql; -struct st_mysql_bind; -struct st_mysql_daemon; -struct st_mysql_data; -struct st_mysql_field; -struct st_mysql_ftparser; -struct st_mysql_ftparser_boolean_info; -struct st_mysql_ftparser_param; -struct st_mysql_information_schema; -struct st_mysql_lex_string; -struct st_mysql_manager; -struct st_mysql_methods; -struct st_mysql_options; -struct st_mysql_parameters; -struct st_mysql_plugin; -struct st_mysql_res; -struct st_mysql_rows; -struct st_mysql_show_var; -struct st_mysql_stmt; -struct st_mysql_storage_engine; -struct st_mysql_time; -struct st_mysql_value; -struct st_mysql_xid; -struct st_net; -struct st_typelib; -struct st_udf_args; -struct st_udf_init; -struct st_used_mem; -enum Item_result; -enum enum_cursor_type; -enum enum_field_types; -enum enum_ft_token_type; -enum enum_ftparser_mode; -enum enum_mysql_set_option; -enum enum_mysql_show_type; -enum enum_mysql_stmt_state; -enum enum_mysql_timestamp_type; -enum enum_server_command; -enum enum_stmt_attr_type; -enum mysql_enum_shutdown_level; -enum mysql_option; -enum mysql_protocol_type; -enum mysql_rpl_type; -enum mysql_status; -# 139 "mysql.h" -typedef struct st_mysql_rows MYSQL_ROWS; -# 23 "my_list.h" -typedef struct st_list LIST; -# 34 "my_alloc.h" -typedef struct st_mem_root MEM_ROOT; -# 258 "mysql.h" -typedef struct st_mysql MYSQL; -# 654 "mysql.h" -typedef struct st_mysql_bind MYSQL_BIND; -# 95 "mysql.h" -typedef struct st_mysql_field MYSQL_FIELD; -# 120 "mysql.h" -typedef unsigned int MYSQL_FIELD_OFFSET; -# 35 "mysql/plugin.h" -typedef struct st_mysql_lex_string MYSQL_LEX_STRING; -# 348 "mysql.h" -typedef struct st_mysql_manager MYSQL_MANAGER; -# 363 "mysql.h" -typedef struct st_mysql_parameters MYSQL_PARAMETERS; -# 316 "mysql.h" -typedef struct st_mysql_res MYSQL_RES; -# 119 "mysql.h" -typedef char * * MYSQL_ROW; -# 145 "mysql.h" -typedef MYSQL_ROWS * MYSQL_ROW_OFFSET; -# 683 "mysql.h" -typedef struct st_mysql_stmt MYSQL_STMT; -# 52 "mysql/plugin.h" -typedef struct st_mysql_xid MYSQL_XID; -# 243 "mysql.h" -typedef struct character_set MY_CHARSET_INFO; -# 188 "mysql_com.h" -typedef struct st_net NET; -# 22 "typelib.h" -typedef struct st_typelib TYPELIB; -# 178 "mysql_com.h" -typedef struct st_vio Vio; -# 28 "my_list.h" -typedef int (* list_walk_action)(void *, void *); -# 51 "mysql.h" -typedef char my_bool; -# 65 "mysql.h" -typedef int my_socket; -# 128 "mysql.h" -typedef unsigned long long int my_ulonglong; -# 214 "/usr/lib/gcc/i486-linux-gnu/4.1.3/include/stddef.h" -typedef unsigned int size_t; -# 149 "mysql.h" -typedef struct embedded_query_result EMBEDDED_QUERY_RESULT; -# 150 "mysql.h" -typedef struct st_mysql_data MYSQL_DATA; -# 495 "mysql/plugin.h" -typedef struct st_mysql_ftparser_boolean_info MYSQL_FTPARSER_BOOLEAN_INFO; -# 557 "mysql/plugin.h" -typedef struct st_mysql_ftparser_param MYSQL_FTPARSER_PARAM; -# 753 "mysql.h" -typedef struct st_mysql_methods MYSQL_METHODS; -# 47 "mysql_time.h" -typedef struct st_mysql_time MYSQL_TIME; -# 383 "mysql_com.h" -typedef struct st_udf_args UDF_ARGS; -# 397 "mysql_com.h" -typedef struct st_udf_init UDF_INIT; -# 26 "my_alloc.h" -typedef struct st_used_mem USED_MEM; -# 123 "mysql/plugin.h" -typedef int (* mysql_show_var_func)(void *, struct st_mysql_show_var *, char *); -# 170 "mysql/plugin.h" -typedef int (* mysql_var_check_func)(void * thd, struct st_mysql_sys_var * var, void * save, struct st_mysql_value * value); -# 188 "mysql/plugin.h" -typedef void (* mysql_var_update_func)(void * thd, struct st_mysql_sys_var * var, void * var_ptr, void * save); -# 243 "mysql.h" -struct __attribute__((aligned(__alignof__(unsigned int)), aligned(__alignof__(void *)))) character_set - { - unsigned int number; - unsigned int state; - char const * csname; - char const * name; - char const * comment; - char const * dir; - unsigned int mbminlen; - unsigned int mbmaxlen; - }; -# 369 "mysql_com.h" -struct __attribute__((aligned(__alignof__(unsigned long int)), aligned(__alignof__(double)))) rand_struct - { - unsigned long int seed1; - unsigned long int seed2; - unsigned long int max_value; - double max_value_dbl; - }; -# 23 "my_list.h" -struct __attribute__((aligned(__alignof__(void *)))) st_list - { - struct st_list * prev; - struct st_list * next; - void * data; - }; -# 34 "my_alloc.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned int)))) st_mem_root - { - USED_MEM * free; - USED_MEM * used; - USED_MEM * pre_alloc; - size_t min_malloc; - size_t block_size; - unsigned int block_num; - unsigned int first_block_usage; - void (* error_handler)(void); - }; -# 258 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long long int)))) st_mysql - { - NET net; - unsigned char * connector_fd; - char * host; - char * user; - char * passwd; - char * unix_socket; - char * server_version; - char * host_info; - char * info; - char * db; - struct charset_info_st * charset; - MYSQL_FIELD * fields; - MEM_ROOT field_alloc; - my_ulonglong affected_rows; - my_ulonglong insert_id; - my_ulonglong extra_info; - unsigned long int thread_id; - unsigned long int packet_length; - unsigned int port; - unsigned long int client_flag; - unsigned long int 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; - my_bool reconnect; - char scramble[(20 + 1)]; - my_bool rpl_pivot; - struct st_mysql * master; - struct st_mysql * next_slave; - struct st_mysql * last_used_slave; - struct st_mysql * last_used_con; - LIST * stmts; - struct st_mysql_methods const * methods; - void * thd; - my_bool * unbuffered_fetch_owner; - char * info_buffer; - void * extension; - }; -# 654 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long int)))) st_mysql_bind - { - unsigned long int * length; - my_bool * is_null; - void * buffer; - my_bool * error; - unsigned char * row_ptr; - 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); - unsigned long int buffer_length; - unsigned long int offset; - unsigned long int length_value; - unsigned int param_number; - unsigned int pack_length; - enum enum_field_types buffer_type; - my_bool error_value; - my_bool is_unsigned; - my_bool long_data_used; - my_bool is_null_value; - void * extension; - }; -# 628 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(int)))) st_mysql_daemon - { - int interface_version; - }; -# 150 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long long int)))) st_mysql_data - { - MYSQL_ROWS * data; - struct embedded_query_result * embedded_info; - MEM_ROOT alloc; - my_ulonglong rows; - unsigned int fields; - void * extension; - }; -# 95 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long int)))) st_mysql_field - { - char * name; - char * org_name; - char * table; - char * org_table; - char * db; - char * catalog; - char * def; - unsigned long int length; - unsigned long int max_length; - 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; - unsigned int decimals; - unsigned int charsetnr; - enum enum_field_types type; - void * extension; - }; -# 581 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(int)), aligned(__alignof__(void *)))) st_mysql_ftparser - { - int interface_version; - int (* parse)(MYSQL_FTPARSER_PARAM * param); - int (* init)(MYSQL_FTPARSER_PARAM * param); - int (* deinit)(MYSQL_FTPARSER_PARAM * param); - }; -# 495 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(int)), aligned(__alignof__(void *)))) st_mysql_ftparser_boolean_info - { - enum enum_ft_token_type type; - int yesno; - int weight_adjust; - char wasign; - char trunc; - char prev; - char * quot; - }; -# 557 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(int)))) st_mysql_ftparser_param - { - int (* mysql_parse)(struct st_mysql_ftparser_param *, char * doc, int); - int (* mysql_add_word)(struct st_mysql_ftparser_param *, char * word, int, MYSQL_FTPARSER_BOOLEAN_INFO * boolean_info); - void * ftparser_state; - void * mysql_ftparam; - struct charset_info_st * cs; - char * doc; - int length; - int flags; - enum enum_ftparser_mode mode; - }; -# 638 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(int)))) st_mysql_information_schema - { - int interface_version; - }; -# 29 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned int)))) st_mysql_lex_string - { - char * str; - unsigned int length; - }; -# 348 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long int)))) st_mysql_manager - { - NET net; - char * host; - char * user; - char * passwd; - char * net_buf; - char * net_buf_pos; - char * net_data_end; - unsigned int port; - int cmd_status; - int last_errno; - int net_buf_size; - my_bool free_me; - my_bool eof; - char last_error[256]; - void * extension; - }; -# 753 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)))) st_mysql_methods - { - my_bool (* read_query_result)(MYSQL * mysql); - my_bool (* advanced_command)(MYSQL * mysql, enum enum_server_command, unsigned char const * header, unsigned long int, unsigned char const * arg, unsigned long int, my_bool, MYSQL_STMT * stmt); - MYSQL_DATA * (* read_rows)(MYSQL * mysql, MYSQL_FIELD * mysql_fields, unsigned int); - MYSQL_RES * (* use_result)(MYSQL * mysql); - void (* fetch_lengths)(unsigned long int * to, MYSQL_ROW, unsigned int); - void (* flush_use_result)(MYSQL * mysql); - 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); - char const * (* read_statistics)(MYSQL * mysql); - my_bool (* next_result)(MYSQL * mysql); - int (* read_change_user_result)(MYSQL * mysql, char * buff, char const * passwd); - int (* read_rows_from_cursor)(MYSQL_STMT * stmt); - }; -# 173 "mysql.h" -struct __attribute__((aligned(__alignof__(unsigned long int)), aligned(__alignof__(void *)))) st_mysql_options - { - unsigned int connect_timeout; - unsigned int read_timeout; - unsigned int write_timeout; - unsigned int port; - unsigned int protocol; - unsigned long int client_flag; - char * host; - char * user; - char * password; - char * unix_socket; - char * db; - struct st_dynamic_array * init_commands; - char * my_cnf_file; - char * my_cnf_group; - char * charset_dir; - char * charset_name; - char * ssl_key; - char * ssl_cert; - char * ssl_ca; - char * ssl_capath; - char * ssl_cipher; - char * shared_memory_base_name; - unsigned long int max_allowed_packet; - my_bool use_ssl; - my_bool compress; - my_bool named_pipe; - my_bool rpl_probe; - my_bool rpl_parse; - my_bool no_master_reads; - my_bool separate_thread; - enum mysql_option methods_to_use; - char * client_ip; - my_bool secure_auth; - my_bool report_data_truncation; - int (* local_infile_init)(void * *, char const *, 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; - void * extension; - }; -# 363 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)))) st_mysql_parameters - { - unsigned long int * p_max_allowed_packet; - unsigned long int * p_net_buffer_length; - void * extension; - }; -# 384 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(int)), aligned(__alignof__(void *)))) st_mysql_plugin - { - int type; - void * info; - char const * name; - char const * author; - char const * descr; - int license; - int (* init)(void); - int (* deinit)(void); - unsigned int version; - struct st_mysql_show_var * status_vars; - struct st_mysql_sys_var * * system_vars; - void * __reserved1; - }; -# 316 "mysql.h" -struct __attribute__((aligned(__alignof__(unsigned long long int)), aligned(__alignof__(void *)))) st_mysql_res - { - my_ulonglong row_count; - MYSQL_FIELD * fields; - MYSQL_DATA * data; - MYSQL_ROWS * data_cursor; - unsigned long int * lengths; - MYSQL * handle; - struct st_mysql_methods const * methods; - MYSQL_ROW row; - MYSQL_ROW current_row; - MEM_ROOT field_alloc; - unsigned int field_count; - unsigned int current_field; - my_bool eof; - my_bool unbuffered_fetch_cancelled; - void * extension; - }; -# 139 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long int)))) st_mysql_rows - { - struct st_mysql_rows * next; - MYSQL_ROW data; - unsigned long int length; - }; -# 116 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(void *)))) st_mysql_show_var - { - char const * name; - char * value; - enum enum_mysql_show_type type; - }; -# 683 "mysql.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long long int)))) st_mysql_stmt - { - MEM_ROOT mem_root; - LIST list; - MYSQL * mysql; - MYSQL_BIND * params; - MYSQL_BIND * bind; - MYSQL_FIELD * fields; - MYSQL_DATA result; - MYSQL_ROWS * data_cursor; - int (* read_row_func)(struct st_mysql_stmt * stmt, unsigned char * * row); - my_ulonglong affected_rows; - my_ulonglong insert_id; - unsigned long int stmt_id; - unsigned long int flags; - unsigned long int prefetch_rows; - unsigned int server_status; - unsigned int last_errno; - unsigned int param_count; - unsigned int field_count; - enum enum_mysql_stmt_state state; - char last_error[512]; - char sqlstate[(5 + 1)]; - my_bool send_types_to_server; - my_bool bind_param_done; - unsigned char bind_result_done; - my_bool unbuffered_fetch_cancelled; - my_bool update_max_length; - void * extension; - }; -# 616 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(int)))) st_mysql_storage_engine - { - int interface_version; - }; -# 47 "mysql_time.h" -struct __attribute__((aligned(__alignof__(unsigned long int)))) st_mysql_time - { - unsigned int year; - unsigned int month; - unsigned int day; - unsigned int hour; - unsigned int minute; - unsigned int second; - unsigned long int second_part; - my_bool neg; - enum enum_mysql_timestamp_type time_type; - }; -# 658 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(void *)))) st_mysql_value - { - int (* value_type)(struct st_mysql_value *); - char const * (* val_str)(struct st_mysql_value *, char * buffer, int * length); - int (* val_real)(struct st_mysql_value *, double * realbuf); - int (* val_int)(struct st_mysql_value *, long long int * intbuf); - }; -# 46 "mysql/plugin.h" -struct __attribute__((aligned(__alignof__(long int)))) st_mysql_xid - { - long int formatID; - long int gtrid_length; - long int bqual_length; - char data[128]; - }; -# 188 "mysql_com.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned long int)))) st_net - { - Vio * vio; - unsigned char * buff; - unsigned char * buff_end; - unsigned char * write_pos; - unsigned char * read_pos; - my_socket fd; - unsigned long int remain_in_buf; - unsigned long int length; - unsigned long int buf_length; - unsigned long int where_b; - unsigned long int max_packet; - unsigned long int max_packet_size; - unsigned int pkt_nr; - unsigned int compress_pkt_nr; - unsigned int write_timeout; - unsigned int read_timeout; - unsigned int retry_count; - int fcntl; - unsigned int * return_status; - unsigned char reading_or_writing; - char save_char; - my_bool unused0; - my_bool unused; - my_bool compress; - my_bool unused1; - unsigned char * query_cache_query; - unsigned int last_errno; - unsigned char error; - my_bool unused2; - my_bool return_errno; - char last_error[512]; - char sqlstate[(5 + 1)]; - void * extension; - }; -# 22 "typelib.h" -struct __attribute__((aligned(__alignof__(unsigned int)), aligned(__alignof__(void *)))) st_typelib - { - unsigned int count; - char const * name; - char const * * type_names; - unsigned int * type_lengths; - }; -# 383 "mysql_com.h" -struct __attribute__((aligned(__alignof__(unsigned int)), aligned(__alignof__(void *)))) st_udf_args - { - unsigned int arg_count; - enum Item_result * arg_type; - char * * args; - unsigned long int * lengths; - char * maybe_null; - char * * attributes; - unsigned long int * attribute_lengths; - void * extension; - }; -# 397 "mysql_com.h" -struct __attribute__((aligned(__alignof__(unsigned long int)), aligned(__alignof__(void *)))) st_udf_init - { - my_bool maybe_null; - unsigned int decimals; - unsigned long int max_length; - char * ptr; - my_bool const_item; - void * extension; - }; -# 26 "my_alloc.h" -struct __attribute__((aligned(__alignof__(void *)), aligned(__alignof__(unsigned int)))) st_used_mem - { - struct st_used_mem * next; - unsigned int left; - unsigned int size; - }; -# 380 "mysql_com.h" -enum Item_result - { - STRING_RESULT = 0, - REAL_RESULT = 1, - INT_RESULT = 2, - ROW_RESULT = 3, - DECIMAL_RESULT = 4, - }; -# 321 "mysql_com.h" -enum enum_cursor_type - { - CURSOR_TYPE_NO_CURSOR = 0, - CURSOR_TYPE_READ_ONLY = 1, - CURSOR_TYPE_FOR_UPDATE = 2, - CURSOR_TYPE_SCROLLABLE = 4, - }; -# 234 "mysql_com.h" -enum enum_field_types - { - MYSQL_TYPE_DECIMAL = 0, - MYSQL_TYPE_TINY = 1, - MYSQL_TYPE_SHORT = 2, - MYSQL_TYPE_LONG = 3, - MYSQL_TYPE_FLOAT = 4, - MYSQL_TYPE_DOUBLE = 5, - MYSQL_TYPE_NULL = 6, - MYSQL_TYPE_TIMESTAMP = 7, - MYSQL_TYPE_LONGLONG = 8, - MYSQL_TYPE_INT24 = 9, - MYSQL_TYPE_DATE = 10, - MYSQL_TYPE_TIME = 11, - MYSQL_TYPE_DATETIME = 12, - MYSQL_TYPE_YEAR = 13, - MYSQL_TYPE_NEWDATE = 14, - MYSQL_TYPE_VARCHAR = 15, - MYSQL_TYPE_BIT = 16, - 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, - }; -# 455 "mysql/plugin.h" -enum enum_ft_token_type - { - FT_TOKEN_EOF = 0, - FT_TOKEN_WORD = 1, - FT_TOKEN_LEFT_PAREN = 2, - FT_TOKEN_RIGHT_PAREN = 3, - FT_TOKEN_STOPWORD = 4, - }; -# 407 "mysql/plugin.h" -enum enum_ftparser_mode - { - MYSQL_FTPARSER_SIMPLE_MODE = 0, - MYSQL_FTPARSER_WITH_STOPWORDS = 1, - MYSQL_FTPARSER_FULL_BOOLEAN_INFO = 2, - }; -# 331 "mysql_com.h" -enum enum_mysql_set_option - { - MYSQL_OPTION_MULTI_STATEMENTS_ON = 0, - MYSQL_OPTION_MULTI_STATEMENTS_OFF = 1, - }; -# 109 "mysql/plugin.h" -enum enum_mysql_show_type - { - SHOW_UNDEF = 0, - SHOW_BOOL = 1, - SHOW_INT = 2, - SHOW_LONG = 3, - SHOW_LONGLONG = 4, - SHOW_CHAR = 5, - SHOW_CHAR_PTR = 6, - SHOW_ARRAY = 7, - SHOW_FUNC = 8, - SHOW_DOUBLE = 9, - }; -# 584 "mysql.h" -enum enum_mysql_stmt_state - { - MYSQL_STMT_INIT_DONE = 1, - MYSQL_STMT_PREPARE_DONE = 2, - MYSQL_STMT_EXECUTE_DONE = 3, - MYSQL_STMT_FETCH_DONE = 4, - }; -# 28 "mysql_time.h" -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, - }; -# 55 "mysql_com.h" -enum enum_server_command - { - COM_SLEEP = 0, - COM_QUIT = 1, - COM_INIT_DB = 2, - COM_QUERY = 3, - COM_FIELD_LIST = 4, - COM_CREATE_DB = 5, - COM_DROP_DB = 6, - COM_REFRESH = 7, - COM_SHUTDOWN = 8, - COM_STATISTICS = 9, - COM_PROCESS_INFO = 10, - COM_CONNECT = 11, - COM_PROCESS_KILL = 12, - COM_DEBUG = 13, - COM_PING = 14, - COM_TIME = 15, - COM_DELAYED_INSERT = 16, - COM_CHANGE_USER = 17, - COM_BINLOG_DUMP = 18, - COM_TABLE_DUMP = 19, - COM_CONNECT_OUT = 20, - COM_REGISTER_SLAVE = 21, - COM_STMT_PREPARE = 22, - COM_STMT_EXECUTE = 23, - COM_STMT_SEND_LONG_DATA = 24, - COM_STMT_CLOSE = 25, - COM_STMT_RESET = 26, - COM_SET_OPTION = 27, - COM_STMT_FETCH = 28, - COM_DAEMON = 29, - COM_END = 30, - }; -# 730 "mysql.h" -enum enum_stmt_attr_type - { - STMT_ATTR_UPDATE_MAX_LENGTH = 0, - STMT_ATTR_CURSOR_TYPE = 1, - STMT_ATTR_PREFETCH_ROWS = 2, - }; -# 296 "mysql_com.h" -enum mysql_enum_shutdown_level - { - SHUTDOWN_DEFAULT = 0, - SHUTDOWN_WAIT_CONNECTIONS = (unsigned char)((1 << 0)), - SHUTDOWN_WAIT_TRANSACTIONS = (unsigned char)((1 << 1)), - SHUTDOWN_WAIT_UPDATES = (unsigned char)((1 << 3)), - SHUTDOWN_WAIT_ALL_BUFFERS = ((unsigned char)((1 << 3)) << 1), - SHUTDOWN_WAIT_CRITICAL_BUFFERS = (((unsigned char)((1 << 3)) << 1) + 1), - KILL_CONNECTION = 255, - }; -# 160 "mysql.h" -enum mysql_option - { - MYSQL_OPT_CONNECT_TIMEOUT = 0, - MYSQL_OPT_COMPRESS = 1, - MYSQL_OPT_NAMED_PIPE = 2, - MYSQL_INIT_COMMAND = 3, - MYSQL_READ_DEFAULT_FILE = 4, - MYSQL_READ_DEFAULT_GROUP = 5, - MYSQL_SET_CHARSET_DIR = 6, - MYSQL_SET_CHARSET_NAME = 7, - MYSQL_OPT_LOCAL_INFILE = 8, - MYSQL_OPT_PROTOCOL = 9, - MYSQL_SHARED_MEMORY_BASE_NAME = 10, - MYSQL_OPT_READ_TIMEOUT = 11, - MYSQL_OPT_WRITE_TIMEOUT = 12, - MYSQL_OPT_USE_RESULT = 13, - MYSQL_OPT_USE_REMOTE_CONNECTION = 14, - MYSQL_OPT_USE_EMBEDDED_CONNECTION = 15, - MYSQL_OPT_GUESS_CONNECTION = 16, - MYSQL_SET_CLIENT_IP = 17, - MYSQL_SECURE_AUTH = 18, - MYSQL_REPORT_DATA_TRUNCATION = 19, - MYSQL_OPT_RECONNECT = 20, - MYSQL_OPT_SSL_VERIFY_SERVER_CERT = 21, - }; -# 228 "mysql.h" -enum mysql_protocol_type - { - MYSQL_PROTOCOL_DEFAULT = 0, - MYSQL_PROTOCOL_TCP = 1, - MYSQL_PROTOCOL_SOCKET = 2, - MYSQL_PROTOCOL_PIPE = 3, - MYSQL_PROTOCOL_MEMORY = 4, - }; -# 238 "mysql.h" -enum mysql_rpl_type - { - MYSQL_RPL_MASTER = 0, - MYSQL_RPL_SLAVE = 1, - MYSQL_RPL_ADMIN = 2, - }; -# 223 "mysql.h" -enum mysql_status - { - MYSQL_STATUS_READY = 0, - MYSQL_STATUS_GET_RESULT = 1, - MYSQL_STATUS_USE_RESULT = 2, - }; -# 441 "mysql_com.h" -extern my_bool check_scramble(char const * reply, char const * message, unsigned char const * hash_stage2); -# 434 "mysql_com.h" -extern my_bool check_scramble_323(char const *, char const * message, unsigned long int * salt); -# 35 "typelib.h" -extern TYPELIB * copy_typelib(MEM_ROOT * root, TYPELIB * from); -# 429 "mysql_com.h" -extern void create_random_string(char * to, unsigned int, struct rand_struct * rand_st); -# 32 "typelib.h" -extern int find_type(char * x, TYPELIB const * typelib, unsigned int); -# 30 "typelib.h" -extern int find_type_or_exit(char const * x, TYPELIB * typelib, char const * option); -# 29 "typelib.h" -extern my_ulonglong find_typeset(char * x, TYPELIB * typelib, int * error_position); -# 443 "mysql_com.h" -extern void get_salt_from_password(unsigned char * res, char const * password); -# 436 "mysql_com.h" -extern void get_salt_from_password_323(unsigned long int * res, char const * password); -# 449 "mysql_com.h" -extern char * get_tty_password(char const * opt_message); -# 34 "typelib.h" -extern char const * get_type(TYPELIB * typelib, unsigned int); -# 431 "mysql_com.h" -extern void hash_password(unsigned long int * to, char const * password, unsigned int); -# 30 "my_list.h" -extern LIST * list_add(LIST * root, LIST * element); -# 32 "my_list.h" -extern LIST * list_cons(void * data, LIST * root); -# 31 "my_list.h" -extern LIST * list_delete(LIST * root, LIST * element); -# 34 "my_list.h" -extern void list_free(LIST * root, unsigned int); -# 35 "my_list.h" -extern unsigned int list_length(LIST *); -# 33 "my_list.h" -extern LIST * list_reverse(LIST * root); -# 36 "my_list.h" -extern int list_walk(LIST *, list_walk_action, unsigned char * argument); -# 444 "mysql_com.h" -extern void make_password_from_salt(char * to, unsigned char const * hash_stage2); -# 437 "mysql_com.h" -extern void make_password_from_salt_323(char * to, unsigned long int const * salt); -# 439 "mysql_com.h" -extern void make_scrambled_password(char * to, char const * password); -# 432 "mysql_com.h" -extern void make_scrambled_password_323(char * to, char const * password); -# 33 "typelib.h" -extern void make_type(char * to, unsigned int, TYPELIB * typelib); -# 366 "mysql_com.h" -extern int my_connect(my_socket, struct sockaddr const * name, unsigned int, unsigned int); -# 343 "mysql_com.h" -extern my_bool my_net_init(NET * net, Vio * vio); -# 344 "mysql_com.h" -extern void my_net_local_init(NET * net); -# 354 "mysql_com.h" -extern unsigned long int my_net_read(NET * net); -# 349 "mysql_com.h" -extern my_bool my_net_write(NET * net, unsigned char const * packet, size_t); -# 428 "mysql_com.h" -extern double my_rnd(struct rand_struct *); -# 455 "mysql_com.h" -extern void my_thread_end(void); -# 454 "mysql_com.h" -extern my_bool my_thread_init(void); -# 560 "mysql.h" -extern void myodbc_remove_escape(MYSQL * mysql, char * name); -# 512 "mysql.h" -extern int mysql_add_slave(MYSQL * mysql, char const * host, unsigned int, char const * user, char const * passwd); -# 421 "mysql.h" -extern my_ulonglong mysql_affected_rows(MYSQL * mysql); -# 826 "mysql.h" -extern my_bool mysql_autocommit(MYSQL * mysql, my_bool); -# 437 "mysql.h" -extern my_bool mysql_change_user(MYSQL * mysql, char const * user, char const * passwd, char const * db); -# 429 "mysql.h" -extern char const * mysql_character_set_name(MYSQL * mysql); -# 829 "mysql.h" -extern void mysql_close(MYSQL * sock); -# 824 "mysql.h" -extern my_bool mysql_commit(MYSQL * mysql); -# 541 "mysql.h" -extern void mysql_data_seek(MYSQL_RES * result, my_ulonglong); -# 559 "mysql.h" -extern void mysql_debug(char const * debug); -# 498 "mysql.h" -extern void mysql_disable_reads_from_master(MYSQL * mysql); -# 492 "mysql.h" -extern void mysql_disable_rpl_parse(MYSQL * mysql); -# 520 "mysql.h" -extern int mysql_dump_debug_info(MYSQL * mysql); -# 562 "mysql.h" -extern my_bool mysql_embedded(void); -# 497 "mysql.h" -extern void mysql_enable_reads_from_master(MYSQL * mysql); -# 491 "mysql.h" -extern void mysql_enable_rpl_parse(MYSQL * mysql); -# 413 "mysql.h" -extern my_bool mysql_eof(MYSQL_RES * res); -# 423 "mysql.h" -extern unsigned int mysql_errno(MYSQL * mysql); -# 450 "mysql_com.h" -extern char const * mysql_errno_to_sqlstate(unsigned int); -# 424 "mysql.h" -extern char const * mysql_error(MYSQL * mysql); -# 552 "mysql.h" -extern unsigned long int mysql_escape_string(char * to, char const * from, unsigned long int); -# 549 "mysql.h" -extern MYSQL_FIELD * mysql_fetch_field(MYSQL_RES * result); -# 414 "mysql.h" -extern MYSQL_FIELD * mysql_fetch_field_direct(MYSQL_RES * res, unsigned int); -# 416 "mysql.h" -extern MYSQL_FIELD * mysql_fetch_fields(MYSQL_RES * res); -# 548 "mysql.h" -extern unsigned long int * mysql_fetch_lengths(MYSQL_RES * result); -# 547 "mysql.h" -extern MYSQL_ROW mysql_fetch_row(MYSQL_RES * result); -# 420 "mysql.h" -extern unsigned int mysql_field_count(MYSQL * mysql); -# 545 "mysql.h" -extern MYSQL_FIELD_OFFSET mysql_field_seek(MYSQL_RES * result, MYSQL_FIELD_OFFSET); -# 418 "mysql.h" -extern MYSQL_FIELD_OFFSET mysql_field_tell(MYSQL_RES * res); -# 540 "mysql.h" -extern void mysql_free_result(MYSQL_RES * result); -# 465 "mysql.h" -extern void mysql_get_character_set_info(MYSQL * mysql, MY_CHARSET_INFO * charset); -# 530 "mysql.h" -extern char const * mysql_get_client_info(void); -# 531 "mysql.h" -extern unsigned long int mysql_get_client_version(void); -# 532 "mysql.h" -extern char const * mysql_get_host_info(MYSQL * mysql); -# 395 "mysql.h" -extern MYSQL_PARAMETERS * mysql_get_parameters(void); -# 534 "mysql.h" -extern unsigned int mysql_get_proto_info(MYSQL * mysql); -# 529 "mysql.h" -extern char const * mysql_get_server_info(MYSQL * mysql); -# 533 "mysql.h" -extern unsigned long int mysql_get_server_version(MYSQL * mysql); -# 436 "mysql.h" -extern char const * mysql_get_ssl_cipher(MYSQL * mysql); -# 554 "mysql.h" -extern unsigned long int mysql_hex_string(char * to, char const * from, unsigned long int); -# 427 "mysql.h" -extern char const * mysql_info(MYSQL * mysql); -# 432 "mysql.h" -extern MYSQL * mysql_init(MYSQL * mysql); -# 422 "mysql.h" -extern my_ulonglong mysql_insert_id(MYSQL * mysql); -# 523 "mysql.h" -extern int mysql_kill(MYSQL * mysql, unsigned long int); -# 535 "mysql.h" -extern MYSQL_RES * mysql_list_dbs(MYSQL * mysql, char const * wild); -# 550 "mysql.h" -extern MYSQL_RES * mysql_list_fields(MYSQL * mysql, char const * table, char const * wild); -# 537 "mysql.h" -extern MYSQL_RES * mysql_list_processes(MYSQL * mysql); -# 536 "mysql.h" -extern MYSQL_RES * mysql_list_tables(MYSQL * mysql, char const * wild); -# 569 "mysql.h" -extern void mysql_manager_close(MYSQL_MANAGER * con); -# 570 "mysql.h" -extern int mysql_manager_command(MYSQL_MANAGER * con, char const * cmd, int); -# 564 "mysql.h" -extern MYSQL_MANAGER * mysql_manager_connect(MYSQL_MANAGER * con, char const * host, char const * user, char const * passwd, unsigned int); -# 572 "mysql.h" -extern int mysql_manager_fetch_line(MYSQL_MANAGER * con, char * res_buf, int); -# 563 "mysql.h" -extern MYSQL_MANAGER * mysql_manager_init(MYSQL_MANAGER * con); -# 456 "mysql.h" -extern my_bool mysql_master_query(MYSQL * mysql, char const * q, unsigned long int); -# 458 "mysql.h" -extern my_bool mysql_master_send_query(MYSQL * mysql, char const * q, unsigned long int); -# 827 "mysql.h" -extern my_bool mysql_more_results(MYSQL * mysql); -# 828 "mysql.h" -extern int mysql_next_result(MYSQL * mysql); -# 412 "mysql.h" -extern unsigned int mysql_num_fields(MYSQL_RES * res); -# 411 "mysql.h" -extern my_ulonglong mysql_num_rows(MYSQL_RES * res); -# 538 "mysql.h" -extern int mysql_options(MYSQL * mysql, enum mysql_option, void const * arg); -# 527 "mysql.h" -extern int mysql_ping(MYSQL * mysql); -# 76 "mysql.h" -extern unsigned int mysql_port; -# 447 "mysql.h" -extern int mysql_query(MYSQL * mysql, char const * q); -# 780 "mysql/plugin.h" -extern void mysql_query_cache_invalidate4(void * thd, char const * key, unsigned int, int); -# 575 "mysql.h" -extern my_bool mysql_read_query_result(MYSQL * mysql); -# 500 "mysql.h" -extern my_bool mysql_reads_from_master_enabled(MYSQL * mysql); -# 439 "mysql.h" -extern MYSQL * mysql_real_connect(MYSQL * mysql, char const * host, char const * user, char const * passwd, char const * db, unsigned int, char const * unix_socket, unsigned long int); -# 556 "mysql.h" -extern unsigned long int mysql_real_escape_string(MYSQL * mysql, char * to, char const * from, unsigned long int); -# 450 "mysql.h" -extern int mysql_real_query(MYSQL * mysql, char const * q, unsigned long int); -# 521 "mysql.h" -extern int mysql_refresh(MYSQL * mysql, unsigned int); -# 825 "mysql.h" -extern my_bool mysql_rollback(MYSQL * mysql); -# 543 "mysql.h" -extern MYSQL_ROW_OFFSET mysql_row_seek(MYSQL_RES * result, MYSQL_ROW_OFFSET); -# 417 "mysql.h" -extern MYSQL_ROW_OFFSET mysql_row_tell(MYSQL_RES * res); -# 494 "mysql.h" -extern int mysql_rpl_parse_enabled(MYSQL * mysql); -# 505 "mysql.h" -extern my_bool mysql_rpl_probe(MYSQL * mysql); -# 502 "mysql.h" -extern enum mysql_rpl_type mysql_rpl_query_type(char const * q, int); -# 446 "mysql.h" -extern int mysql_select_db(MYSQL * mysql, char const * db); -# 448 "mysql.h" -extern int mysql_send_query(MYSQL * mysql, char const * q, unsigned long int); -# 381 "mysql.h" -extern void mysql_server_end(void); -# 380 "mysql.h" -extern int mysql_server_init(int, char * * argv, char * * groups); -# 430 "mysql.h" -extern int mysql_set_character_set(MYSQL * mysql, char const * csname); -# 483 "mysql.h" -extern void mysql_set_local_infile_default(MYSQL * mysql); -# 472 "mysql.h" -extern void mysql_set_local_infile_handler(MYSQL * mysql, int (* local_infile_init)(void * *, char const *, void *), int (* local_infile_read)(void *, char *, unsigned int), void (* local_infile_end)(void), int (* local_infile_error)(void *, char *, unsigned int), void *); -# 508 "mysql.h" -extern int mysql_set_master(MYSQL * mysql, char const * host, unsigned int, char const * user, char const * passwd); -# 524 "mysql.h" -extern int mysql_set_server_option(MYSQL * mysql, enum enum_mysql_set_option); -# 517 "mysql.h" -extern int mysql_shutdown(MYSQL * mysql, enum mysql_enum_shutdown_level); -# 461 "mysql.h" -extern my_bool mysql_slave_query(MYSQL * mysql, char const * q, unsigned long int); -# 463 "mysql.h" -extern my_bool mysql_slave_send_query(MYSQL * mysql, char const * q, unsigned long int); -# 425 "mysql.h" -extern char const * mysql_sqlstate(MYSQL * mysql); -# 433 "mysql.h" -extern my_bool mysql_ssl_set(MYSQL * mysql, char const * key, char const * cert, char const * ca, char const * capath, char const * cipher); -# 528 "mysql.h" -extern char const * mysql_stat(MYSQL * mysql); -# 820 "mysql.h" -extern my_ulonglong mysql_stmt_affected_rows(MYSQL_STMT * stmt); -# 798 "mysql.h" -extern my_bool mysql_stmt_attr_get(MYSQL_STMT * stmt, enum enum_stmt_attr_type, void * attr); -# 795 "mysql.h" -extern my_bool mysql_stmt_attr_set(MYSQL_STMT * stmt, enum enum_stmt_attr_type, void const * attr); -# 801 "mysql.h" -extern my_bool mysql_stmt_bind_param(MYSQL_STMT * stmt, MYSQL_BIND * bnd); -# 802 "mysql.h" -extern my_bool mysql_stmt_bind_result(MYSQL_STMT * stmt, MYSQL_BIND * bnd); -# 803 "mysql.h" -extern my_bool mysql_stmt_close(MYSQL_STMT * stmt); -# 818 "mysql.h" -extern void mysql_stmt_data_seek(MYSQL_STMT * stmt, my_ulonglong); -# 812 "mysql.h" -extern unsigned int mysql_stmt_errno(MYSQL_STMT * stmt); -# 813 "mysql.h" -extern char const * mysql_stmt_error(MYSQL_STMT * stmt); -# 788 "mysql.h" -extern int mysql_stmt_execute(MYSQL_STMT * stmt); -# 789 "mysql.h" -extern int mysql_stmt_fetch(MYSQL_STMT * stmt); -# 790 "mysql.h" -extern int mysql_stmt_fetch_column(MYSQL_STMT * stmt, MYSQL_BIND * bind_arg, unsigned int, unsigned long int); -# 822 "mysql.h" -extern unsigned int mysql_stmt_field_count(MYSQL_STMT * stmt); -# 805 "mysql.h" -extern my_bool mysql_stmt_free_result(MYSQL_STMT * stmt); -# 785 "mysql.h" -extern MYSQL_STMT * mysql_stmt_init(MYSQL * mysql); -# 821 "mysql.h" -extern my_ulonglong mysql_stmt_insert_id(MYSQL_STMT * stmt); -# 819 "mysql.h" -extern my_ulonglong mysql_stmt_num_rows(MYSQL_STMT * stmt); -# 794 "mysql.h" -extern unsigned long int mysql_stmt_param_count(MYSQL_STMT * stmt); -# 811 "mysql.h" -extern MYSQL_RES * mysql_stmt_param_metadata(MYSQL_STMT * stmt); -# 786 "mysql.h" -extern int mysql_stmt_prepare(MYSQL_STMT * stmt, char const * query, unsigned long int); -# 804 "mysql.h" -extern my_bool mysql_stmt_reset(MYSQL_STMT * stmt); -# 810 "mysql.h" -extern MYSQL_RES * mysql_stmt_result_metadata(MYSQL_STMT * stmt); -# 815 "mysql.h" -extern MYSQL_ROW_OFFSET mysql_stmt_row_seek(MYSQL_STMT * stmt, MYSQL_ROW_OFFSET); -# 817 "mysql.h" -extern MYSQL_ROW_OFFSET mysql_stmt_row_tell(MYSQL_STMT * stmt); -# 806 "mysql.h" -extern my_bool mysql_stmt_send_long_data(MYSQL_STMT * stmt, unsigned int, char const * data, unsigned long int); -# 814 "mysql.h" -extern char const * mysql_stmt_sqlstate(MYSQL_STMT * stmt); -# 793 "mysql.h" -extern int mysql_stmt_store_result(MYSQL_STMT * stmt); -# 452 "mysql.h" -extern MYSQL_RES * mysql_store_result(MYSQL * mysql); -# 404 "mysql.h" -extern void mysql_thread_end(void); -# 428 "mysql.h" -extern unsigned long int mysql_thread_id(MYSQL * mysql); -# 403 "mysql.h" -extern my_bool mysql_thread_init(void); -# 561 "mysql.h" -extern unsigned int mysql_thread_safe(void); -# 699 "mysql/plugin.h" -extern int mysql_tmpfile(char const * prefix); -# 77 "mysql.h" -extern char * mysql_unix_port; -# 453 "mysql.h" -extern MYSQL_RES * mysql_use_result(MYSQL * mysql); -# 426 "mysql.h" -extern unsigned int mysql_warning_count(MYSQL * mysql); -# 346 "mysql_com.h" -extern void net_clear(NET * net, my_bool); -# 345 "mysql_com.h" -extern void net_end(NET * net); -# 348 "mysql_com.h" -extern my_bool net_flush(NET * net); -# 353 "mysql_com.h" -extern int net_real_write(NET * net, unsigned char const * packet, size_t); -# 347 "mysql_com.h" -extern my_bool net_realloc(NET * net, size_t); -# 350 "mysql_com.h" -extern my_bool net_write_command(NET * net, unsigned char, unsigned char const * header, size_t, unsigned char const * packet, size_t); -# 445 "mysql_com.h" -extern char * octet2hex(char * to, char const * str, unsigned int); -# 426 "mysql_com.h" -extern void randominit(struct rand_struct *, unsigned long int, unsigned long int); -# 440 "mysql_com.h" -extern void scramble(char * to, char const * message, char const * password); -# 433 "mysql_com.h" -extern void scramble_323(char * to, char const * message, char const * password); -# 37 "typelib.h" -extern TYPELIB sql_protocol_typelib; -# 729 "mysql/plugin.h" -extern void * thd_alloc(void * thd, unsigned int); -# 733 "mysql/plugin.h" -extern void * thd_calloc(void * thd, unsigned int); -# 770 "mysql/plugin.h" -extern void thd_get_xid(void const * thd, MYSQL_XID * xid); -# 680 "mysql/plugin.h" -extern void * * thd_ha_data(void const * thd, struct handlerton const * hton); -# 675 "mysql/plugin.h" -extern int thd_in_lock_tables(void const * thd); -# 685 "mysql/plugin.h" -extern void thd_inc_row_count(void); -# 715 "mysql/plugin.h" -extern int thd_killed(void const * thd); -# 760 "mysql/plugin.h" -extern MYSQL_LEX_STRING * thd_make_lex_string(void * thd, MYSQL_LEX_STRING * lex_str, char const * str, unsigned int, int); -# 745 "mysql/plugin.h" -extern void * thd_memdup(void * thd, void const * str, unsigned int); -# 679 "mysql/plugin.h" -extern char const * thd_proc_info(void * thd, char const * info); -# 682 "mysql/plugin.h" -extern char * thd_security_context(void * thd, char * buffer, unsigned int, unsigned int); -# 678 "mysql/plugin.h" -extern int thd_sql_command(void const * thd); -# 737 "mysql/plugin.h" -extern char * thd_strdup(void * thd, char const * str); -# 741 "mysql/plugin.h" -extern char * thd_strmake(void * thd, char const * str, unsigned int); -# 676 "mysql/plugin.h" -extern int thd_tablespace_op(void const * thd); -# 677 "mysql/plugin.h" -extern long long int thd_test_options(void const * thd, long long int); -# 681 "mysql/plugin.h" -extern int thd_tx_isolation(void const * thd); diff --git a/libmysql/dll.c b/libmysql/dll.c index 7aa3b5bf96f..8fcf41c792c 100644 --- a/libmysql/dll.c +++ b/libmysql/dll.c @@ -89,9 +89,20 @@ BOOL APIENTRY LibMain(HANDLE hInst,DWORD ul_reason_being_called, UNREFERENCED_PARAMETER(lpReserved); } /* LibMain */ + +static BOOL do_libmain; int __stdcall DllMain(HANDLE hInst,DWORD ul_reason_being_called,LPVOID lpReserved) { - return LibMain(hInst,ul_reason_being_called,lpReserved); + /* + Unless environment variable LIBMYSQL_DLLINIT is set, do nothing. + The environment variable is checked once, during the first call to DllMain() + (in DLL_PROCESS_ATTACH hook). + */ + if (ul_reason_being_called == DLL_PROCESS_ATTACH) + do_libmain = (getenv("LIBMYSQL_DLLINIT") != NULL); + if (do_libmain) + return LibMain(hInst,ul_reason_being_called,lpReserved); + return TRUE; } #elif defined(WINDOWS) diff --git a/mysql-test/extra/rpl_tests/rpl_ddl.test b/mysql-test/extra/rpl_tests/rpl_ddl.test index e40532f005f..f1064dc268f 100644 --- a/mysql-test/extra/rpl_tests/rpl_ddl.test +++ b/mysql-test/extra/rpl_tests/rpl_ddl.test @@ -151,6 +151,20 @@ DROP DATABASE IF EXISTS mysqltest3; CREATE DATABASE mysqltest1; CREATE DATABASE mysqltest2; eval CREATE TABLE mysqltest1.t1 (f1 BIGINT) ENGINE=$engine_type; +# Prevent Bug#26687 rpl_ddl test fails if run with --innodb option +# The testscript (suite/rpl/rpl_ddl.test) + the expected result need that the +# slave uses MyISAM for the table mysqltest.t1. +# This is not valid in case of suite/rpl_ndb/rpl_ndb_ddl.test which sources +# also this script. +sync_slave_with_master; +connection slave; +if (`SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES + WHERE TABLE_SCHEMA = 'mysqltest1' AND TABLE_NAME = 't1' + AND ENGINE <> 'MyISAM' AND '$engine_type' <> 'NDB'`) +{ + skip This test needs on slave side: InnoDB disabled, default engine: MyISAM; +} +connection master; INSERT INTO mysqltest1.t1 SET f1= 0; eval CREATE TABLE mysqltest1.t2 (f1 BIGINT) ENGINE=$engine_type; eval CREATE TABLE mysqltest1.t3 (f1 BIGINT) ENGINE=$engine_type; diff --git a/mysql-test/extra/rpl_tests/rpl_log.test b/mysql-test/extra/rpl_tests/rpl_log.test index 3681600a46e..a7e5de6b7c1 100644 --- a/mysql-test/extra/rpl_tests/rpl_log.test +++ b/mysql-test/extra/rpl_tests/rpl_log.test @@ -11,22 +11,15 @@ # (otherwise RESET MASTER may come too early). sync_slave_with_master; source include/stop_slave.inc; +--source include/wait_for_slave_to_stop.inc reset master; reset slave; -# We are going to read the slave's binlog which contains file_id (for some LOAD -# DATA INFILE); to make it repeatable (not influenced by other tests), we need -# to stop and start the slave, to be sure file_id will start from 1. -# This can be done with 'server_stop slave', but -# this would require the manager, so most of the time the test will be skipped -# :( -# To workaround this, I (Guilhem) add a (empty) rpl_log-slave.opt (because when -# mysql-test-run finds such a file it restarts the slave before doing the -# test). That's not very elegant but I could find no better way, sorry. +start slave; +--source include/wait_for_slave_to_start.inc let $VERSION=`select version()`; connection master; -reset master; eval create table t1(n int not null auto_increment primary key)ENGINE=$engine_type; insert into t1 values (NULL); drop table t1; @@ -95,14 +88,17 @@ eval create table t2 (n int)ENGINE=$engine_type; insert into t2 values (1); source include/show_binlog_events.inc; --replace_result $VERSION VERSION +--replace_regex /file_id=[0-9]+/file_id=#/ /block_len=[0-9]+/block_len=#/ /infile '.+'/infile 'words.dat'/ --replace_column 2 # 5 # --replace_regex /\/\* xid=.* \*\//\/* XID *\// /table_id: [0-9]+/table_id: #/ show binlog events in 'master-bin.000002'; show binary logs; sync_slave_with_master; +--source include/wait_for_slave_to_start.inc show binary logs; --replace_result $MASTER_MYPORT MASTER_PORT $VERSION VERSION --replace_column 2 # 5 # +--replace_regex /file_id=[0-9]+/file_id=#/ /block_len=[0-9]+/block_len=#/ /INFILE '.+'/INFILE 'words.dat'/ --replace_regex /\/\* xid=.* \*\//\/* XID *\// /table_id: [0-9]+/table_id: #/ show binlog events in 'slave-bin.000001' from 4; --replace_result $MASTER_MYPORT MASTER_PORT $VERSION VERSION diff --git a/mysql-test/extra/rpl_tests/rpl_row_basic.test b/mysql-test/extra/rpl_tests/rpl_row_basic.test index 534842218b9..7cfbcdb4437 100644 --- a/mysql-test/extra/rpl_tests/rpl_row_basic.test +++ b/mysql-test/extra/rpl_tests/rpl_row_basic.test @@ -451,3 +451,23 @@ connection master; drop table t1, t2, t3, t4, t5, t6, t7; sync_slave_with_master; +# +# BUG#32709: Assertion failed: trx_data->empty(), file .\log.cc, line 1293 +# + +connection master; +eval CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE=$type; + +INSERT INTO t1 VALUES (1), (2), (3); +--error ER_DUP_ENTRY +UPDATE t1 SET a = 10; +INSERT INTO t1 VALUES (4); +sync_slave_with_master; + +let $diff_table_1=master:test.t1; +let $diff_table_2=slave:test.t1; +source include/diff_tables.inc; + +connection master; +drop table t1; +sync_slave_with_master; diff --git a/mysql-test/include/grant_cache.inc b/mysql-test/include/grant_cache.inc index dd65d1ed726..501e115f0ee 100644 --- a/mysql-test/include/grant_cache.inc +++ b/mysql-test/include/grant_cache.inc @@ -136,7 +136,7 @@ connect (user3,localhost,mysqltest_3,,mysqltest,$MASTER_MYPORT,$MASTER_MYSOCK); connection user3; select "user3"; --replace_result 127.0.0.1 localhost ---error ER_COLUMNACCESS_DENIED_ERROR +--error ER_TABLEACCESS_DENIED_ERROR select * from t1; select a from t1; --replace_result 127.0.0.1 localhost diff --git a/mysql-test/r/create.result b/mysql-test/r/create.result index 34820153f13..0644210eef3 100644 --- a/mysql-test/r/create.result +++ b/mysql-test/r/create.result @@ -1559,6 +1559,17 @@ SHOW INDEX FROM t1; Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment t1 1 c1 1 c1 A NULL NULL NULL YES BTREE DROP TABLE t1; +CREATE TABLE t1 (a INTEGER AUTO_INCREMENT PRIMARY KEY, b INTEGER NOT NULL); +INSERT IGNORE INTO t1 (b) VALUES (5); +CREATE TABLE IF NOT EXISTS t2 (a INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY) +SELECT a FROM t1; +CREATE TABLE IF NOT EXISTS t2 (a INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY) +SELECT a FROM t1; +ERROR 23000: Duplicate entry '1' for key 'PRIMARY' +CREATE TABLE IF NOT EXISTS t2 (a INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY) +SELECT a FROM t1; +ERROR 23000: Duplicate entry '1' for key 'PRIMARY' +DROP TABLE t1, t2; End of 5.0 tests CREATE TABLE t1 (a int, b int); insert into t1 values (1,1),(1,2); diff --git a/mysql-test/r/default.result b/mysql-test/r/default.result index e65e015eff9..5b0d82407a2 100644 --- a/mysql-test/r/default.result +++ b/mysql-test/r/default.result @@ -205,4 +205,19 @@ Warnings: Warning 1364 Field 'id' doesn't have a default value drop view v1; drop table t1; +create table t1 (a int unique); +create table t2 (b int default 10); +insert into t1 (a) values (1); +insert into t2 (b) values (1); +insert into t1 (a) select b from t2 on duplicate key update a=default; +select * from t1; +a +NULL +insert into t1 (a) values (1); +insert into t1 (a) select b from t2 on duplicate key update a=default(b); +select * from t1; +a +NULL +10 +drop table t1, t2; End of 5.0 tests. diff --git a/mysql-test/r/func_regexp.result b/mysql-test/r/func_regexp.result index b64f0b7f1c1..54aad23402f 100644 --- a/mysql-test/r/func_regexp.result +++ b/mysql-test/r/func_regexp.result @@ -114,6 +114,18 @@ End of 4.1 tests SELECT 1 REGEXP NULL; 1 REGEXP NULL NULL +SELECT '' REGEXP BINARY NULL; +'' REGEXP BINARY NULL +NULL +SELECT NULL REGEXP BINARY NULL; +NULL REGEXP BINARY NULL +NULL +SELECT 'A' REGEXP BINARY NULL; +'A' REGEXP BINARY NULL +NULL +SELECT "ABC" REGEXP BINARY NULL; +"ABC" REGEXP BINARY NULL +NULL End of 5.0 tests CREATE TABLE t1(a INT, b CHAR(4)); INSERT INTO t1 VALUES (1, '6.1'), (1, '7.0'), (1, '8.0'); diff --git a/mysql-test/r/grant2.result b/mysql-test/r/grant2.result index 098f35e3fa0..0c3bd2f48aa 100644 --- a/mysql-test/r/grant2.result +++ b/mysql-test/r/grant2.result @@ -435,7 +435,7 @@ USE db1; SELECT c FROM t2; ERROR 42000: SELECT command denied to user 'mysqltest1'@'localhost' for column 'c' in table 't2' SELECT * FROM t2; -ERROR 42000: SELECT command denied to user 'mysqltest1'@'localhost' for column 'c' in table 't2' +ERROR 42000: SELECT command denied to user 'mysqltest1'@'localhost' for table 't2' SELECT * FROM t1 JOIN t2 USING (b); ERROR 42000: SELECT command denied to user 'mysqltest1'@'localhost' for column 'c' in table 't2' DROP TABLE db1.t1, db1.t2; diff --git a/mysql-test/r/grant_cache_no_prot.result b/mysql-test/r/grant_cache_no_prot.result index 02360c4c325..cb9acaf540d 100644 --- a/mysql-test/r/grant_cache_no_prot.result +++ b/mysql-test/r/grant_cache_no_prot.result @@ -155,7 +155,7 @@ select "user3"; user3 user3 select * from t1; -ERROR 42000: SELECT command denied to user 'mysqltest_3'@'localhost' for column 'b' in table 't1' +ERROR 42000: SELECT command denied to user 'mysqltest_3'@'localhost' for table 't1' select a from t1; a 1 diff --git a/mysql-test/r/grant_cache_ps_prot.result b/mysql-test/r/grant_cache_ps_prot.result index 1e2cd1baa3a..cf1450f3b75 100644 --- a/mysql-test/r/grant_cache_ps_prot.result +++ b/mysql-test/r/grant_cache_ps_prot.result @@ -155,7 +155,7 @@ select "user3"; user3 user3 select * from t1; -ERROR 42000: SELECT command denied to user 'mysqltest_3'@'localhost' for column 'b' in table 't1' +ERROR 42000: SELECT command denied to user 'mysqltest_3'@'localhost' for table 't1' select a from t1; a 1 diff --git a/mysql-test/r/skip_log_bin.result b/mysql-test/r/skip_log_bin.result new file mode 100644 index 00000000000..2fdd88ff526 --- /dev/null +++ b/mysql-test/r/skip_log_bin.result @@ -0,0 +1,6 @@ +DROP TABLE IF EXISTS t1, t2; +set @@session.binlog_format=row; +create table t1 (a int); +insert into t1 values (1); +create table t2 select * from t1; +drop table t1, t2; diff --git a/mysql-test/r/status.result b/mysql-test/r/status.result index b6f855d96cb..97547ff7c47 100644 --- a/mysql-test/r/status.result +++ b/mysql-test/r/status.result @@ -180,3 +180,21 @@ Variable_name Value Com_alter_function 0 Com_create_function 1 Com_drop_function 1 +create database db37908; +create table db37908.t1(f1 int); +insert into db37908.t1 values(1); +grant usage,execute on test.* to mysqltest_1@localhost; +create procedure proc37908() begin select 1; end | +create function func37908() returns int sql security invoker +return (select * from db37908.t1 limit 1)| +select * from db37908.t1; +ERROR 42000: SELECT command denied to user 'mysqltest_1'@'localhost' for table 't1' +show status where variable_name ='uptime' and 2 in (select * from db37908.t1); +ERROR 42000: SELECT command denied to user 'mysqltest_1'@'localhost' for table 't1' +show procedure status where name ='proc37908' and 1 in (select f1 from db37908.t1); +ERROR 42000: SELECT command denied to user 'mysqltest_1'@'localhost' for table 't1' +show function status where name ='func37908' and 1 in (select func37908()); +ERROR 42000: SELECT command denied to user 'mysqltest_1'@'localhost' for table 't1' +drop database db37908; +drop procedure proc37908; +drop function func37908; diff --git a/mysql-test/r/type_datetime.result b/mysql-test/r/type_datetime.result index d485c468a39..6a692ed58e4 100644 --- a/mysql-test/r/type_datetime.result +++ b/mysql-test/r/type_datetime.result @@ -560,6 +560,29 @@ select * from t2 where id in (select id from t2 as x1 where (t2.cur_date is null)); id cur_date drop table t1,t2; +SELECT +CAST('NULL' AS DATE) <=> CAST('2008-01-01' AS DATE) n1, +CAST('2008-01-01' AS DATE) <=> CAST('NULL' AS DATE) n2, +CAST('NULL' AS DATE) <=> CAST('NULL' AS DATE) n3, +CAST('NULL' AS DATE) <> CAST('2008-01-01' AS DATE) n4, +CAST('2008-01-01' AS DATE) <> CAST('NULL' AS DATE) n5, +CAST('NULL' AS DATE) <> CAST('NULL' AS DATE) n6, +CAST('NULL' AS DATE) < CAST('2008-01-01' AS DATE) n7, +CAST('2008-01-01' AS DATE) < CAST('NULL' AS DATE) n8, +CAST('NULL' AS DATE) < CAST('NULL' AS DATE) n9; +n1 n2 n3 n4 n5 n6 n7 n8 n9 +0 0 1 NULL NULL NULL NULL NULL NULL +Warnings: +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' +Warning 1292 Incorrect datetime value: 'NULL' End of 5.0 tests set @org_mode=@@sql_mode; create table t1 (da date default '1962-03-03 23:33:34', dt datetime default '1962-03-03'); diff --git a/mysql-test/r/type_set.result b/mysql-test/r/type_set.result index e36f21f2996..09531ec60d5 100644 --- a/mysql-test/r/type_set.result +++ b/mysql-test/r/type_set.result @@ -93,4 +93,14 @@ c 1,2,3 64 DROP TABLE t1; +CREATE TABLE t1 ( +set_unique_utf8 set ('a','b','c','d','e','f','g','h','i','j','k','l', +'m','n','o','p','q','r','s','t','u','v','w','x', +'y','z') CHARACTER SET utf8, +unique (set_unique_utf8) +); +INSERT INTO t1 ( set_unique_utf8 ) VALUES ( '' ); +INSERT INTO t1 ( set_unique_utf8 ) VALUES ( '' ); +ERROR 23000: Duplicate entry '' for key 'set_unique_utf8' +DROP TABLE t1; End of 5.0 tests diff --git a/mysql-test/r/view_grant.result b/mysql-test/r/view_grant.result index 3585635d0f9..1821e50e294 100644 --- a/mysql-test/r/view_grant.result +++ b/mysql-test/r/view_grant.result @@ -957,3 +957,42 @@ Warning 1356 View 'test.v1' references invalid table(s) or column(s) or function DROP VIEW v1; DROP TABLE t1; End of 5.1 tests. +CREATE USER mysqluser1@localhost; +CREATE DATABASE mysqltest1; +USE mysqltest1; +CREATE TABLE t1 ( a INT, b INT ); +CREATE TABLE t2 ( a INT, b INT ); +CREATE VIEW v1 AS SELECT a, b FROM t1; +GRANT SELECT( a ) ON v1 TO mysqluser1@localhost; +GRANT UPDATE( b ) ON t2 TO mysqluser1@localhost; +SELECT * FROM mysqltest1.v1; +ERROR 42000: SELECT command denied to user 'mysqluser1'@'localhost' for table 'v1' +CREATE VIEW v1 AS SELECT * FROM mysqltest1.t2; +ERROR 42000: ANY command denied to user 'mysqluser1'@'localhost' for table 't2' +DROP TABLE t1, t2; +DROP VIEW v1; +DROP DATABASE mysqltest1; +DROP USER mysqluser1@localhost; +CREATE USER mysqluser1@localhost; +CREATE DATABASE mysqltest1; +USE mysqltest1; +CREATE VIEW v1 AS SELECT * FROM information_schema.tables LIMIT 1; +CREATE ALGORITHM = TEMPTABLE VIEW v2 AS SELECT 1 AS A; +CREATE VIEW test.v3 AS SELECT 1 AS a; +GRANT SELECT ON mysqltest1.* to mysqluser1@localhost; +GRANT ALL ON test.* TO mysqluser1@localhost; +PREPARE stmt_v1 FROM "SELECT * FROM mysqltest1.v1"; +PREPARE stmt_v2 FROM "SELECT * FROM mysqltest1.v2"; +REVOKE SELECT ON mysqltest1.* FROM mysqluser1@localhost; +EXECUTE stmt_v1; +ERROR 42000: SELECT command denied to user 'mysqluser1'@'localhost' for table 'v1' +EXECUTE stmt_v2; +ERROR 42000: SELECT command denied to user 'mysqluser1'@'localhost' for table 'v2' +PREPARE stmt FROM "SELECT a FROM v3"; +EXECUTE stmt; +a +1 +DROP VIEW v1, v2; +DROP DATABASE mysqltest1; +DROP VIEW test.v3; +DROP USER mysqluser1@localhost; diff --git a/mysql-test/suite/binlog/r/binlog_grant.result b/mysql-test/suite/binlog/r/binlog_grant.result new file mode 100644 index 00000000000..21ebb891103 --- /dev/null +++ b/mysql-test/suite/binlog/r/binlog_grant.result @@ -0,0 +1,28 @@ +reset master; +set @saved_binlog_format = @@global.binlog_format; +create user mysqltest_1@localhost; +show grants for mysqltest_1@localhost; +Grants for mysqltest_1@localhost +GRANT USAGE ON *.* TO 'mysqltest_1'@'localhost' +**** Variable SQL_LOG_BIN **** +[root] +set global sql_log_bin = 1; +ERROR HY000: Variable 'sql_log_bin' is a SESSION variable and can't be used with SET GLOBAL +set session sql_log_bin = 1; +[plain] +set global sql_log_bin = 1; +ERROR HY000: Variable 'sql_log_bin' is a SESSION variable and can't be used with SET GLOBAL +set session sql_log_bin = 1; +ERROR 42000: Access denied; you need the SUPER privilege for this operation +**** Variable BINLOG_FORMAT **** +[root] +set global binlog_format = row; +set session binlog_format = row; +[plain] +set global binlog_format = row; +ERROR 42000: Access denied; you need the SUPER privilege for this operation +set session binlog_format = row; +ERROR 42000: Access denied; you need the SUPER privilege for this operation +**** Clean up **** +set global binlog_format = @saved_binlog_format; +drop user mysqltest_1@localhost; diff --git a/mysql-test/suite/binlog/t/binlog_grant.test b/mysql-test/suite/binlog/t/binlog_grant.test new file mode 100644 index 00000000000..d36dcce4cc3 --- /dev/null +++ b/mysql-test/suite/binlog/t/binlog_grant.test @@ -0,0 +1,60 @@ +# Test grants for various objects (especially variables) related to +# the binary log + +source include/have_log_bin.inc; + +connection default; +--disable_warnings +reset master; +--enable_warnings + +set @saved_binlog_format = @@global.binlog_format; +create user mysqltest_1@localhost; +show grants for mysqltest_1@localhost; + +connect (plain,localhost,mysqltest_1,,test); +connect (root,localhost,root,,test); + +# Testing setting both session and global SQL_LOG_BIN variable both as +# root and as plain user. + +--echo **** Variable SQL_LOG_BIN **** + +connection root; +--echo [root] +--error ER_LOCAL_VARIABLE +set global sql_log_bin = 1; +set session sql_log_bin = 1; + +connection plain; +--echo [plain] +--error ER_LOCAL_VARIABLE +set global sql_log_bin = 1; +--error ER_SPECIFIC_ACCESS_DENIED_ERROR +set session sql_log_bin = 1; + + +# Testing setting both session and global BINLOG_FORMAT variable both +# as root and as plain user. + +--echo **** Variable BINLOG_FORMAT **** + +connection root; +--echo [root] +set global binlog_format = row; +set session binlog_format = row; + +connection plain; +--echo [plain] +--error ER_SPECIFIC_ACCESS_DENIED_ERROR +set global binlog_format = row; +--error ER_SPECIFIC_ACCESS_DENIED_ERROR +set session binlog_format = row; + +--echo **** Clean up **** +disconnect plain; +disconnect root; + +connection default; +set global binlog_format = @saved_binlog_format; +drop user mysqltest_1@localhost; diff --git a/mysql-test/suite/funcs_1/datadict/processlist_priv.inc b/mysql-test/suite/funcs_1/datadict/processlist_priv.inc index 66c43c750fd..d8e1b398bfc 100644 --- a/mysql-test/suite/funcs_1/datadict/processlist_priv.inc +++ b/mysql-test/suite/funcs_1/datadict/processlist_priv.inc @@ -16,7 +16,7 @@ # That means our SHOW PROCESSLIST can come too early. # # Solution: # # Close the connections at the end of the test. # -# Example2: # +# Example2 (2008-08-14 again observed): # # 1. connection X: SHOW PROCESSLIST/GRANT ... etc. # # 2. Switch to connection Y # # 3. SHOW PROCESSLIST might present a record like # @@ -53,9 +53,11 @@ # WL#3982 Test information_schema.processlist # # # # Last update: # -# 2008-04-14 pcrews replace HOST to account for Windows' use of # -# localhost (host:<port> causing diffs on Windows # -# test runs # +# 2008-08-14 mleich Bug#38270 Test "processlist_priv_ps" fails on # +# varying "processlist" output # +# - Replace one sleep by a poll routines # +# - Remove or disable superfluous sleeps # +# # ######################################################################## # The following variables are used in "datadict_priv.inc" and here. @@ -87,15 +89,28 @@ USE information_schema; --echo 1 Prepare test. --echo connection default (user=root) --echo #################################################################################### +if (`SELECT COUNT(*) <> 1 FROM processlist`) +{ + --echo This test expects one connection to the server. + --echo Expectation: USER HOST DB COMMAND STATE INFO + --echo Expectation: root localhost information_schema Query executing SELECT USER,HOST,DB,COMMAND,STATE,INFO FROM processlist ORDER BY ID + --echo But we found in the moment: + SELECT USER,HOST,DB,COMMAND,STATE,INFO FROM processlist ORDER BY ID; + --echo Maybe + --echo - the base configuration (no of parallel auxiliary sessions) of the server has changed + --echo - a parallel test intended for another server accidently connected to our current one + --echo We cannot proceed in this situation. Abort + exit; +} --echo #################################################################################### --echo 1.1 Create two user --echo #################################################################################### # access to info tables as normal user ---disable_abort_on_error +--error 0, ER_CANNOT_USER DROP USER ddicttestuser1@'localhost'; +--error 0, ER_CANNOT_USER DROP USER ddicttestuser2@'localhost'; ---enable_abort_on_error CREATE USER ddicttestuser1@'localhost'; CREATE USER ddicttestuser2@'localhost'; SET PASSWORD FOR ddicttestuser1@'localhost' = PASSWORD('ddictpass'); @@ -112,6 +127,14 @@ connect (con100,localhost,ddicttestuser1,ddictpass,information_schema); --echo SHOW/SELECT shows all processes/threads. --echo #################################################################################### connection default; +# Avoid Bug#38270 Test "processlist_priv_ps" fails on varying "processlist" output +# This subtest expects that the connection con100 is in state 'Sleep'. +# Poll till the connection con100 is in state COMMAND = 'Sleep'. +let $wait_timeout= 10; +let $wait_condition= +SELECT COUNT(*) = 1 FROM INFORMATION_SCHEMA.PROCESSLIST +WHERE DB = 'information_schema' AND COMMAND = 'Sleep' AND USER = 'ddicttestuser1'; +--source include/wait_condition.inc eval SHOW CREATE TABLE $table; --replace_column 1 ID 3 HOST_NAME 6 TIME eval SHOW $table; @@ -120,7 +143,6 @@ eval SELECT * FROM $table $select_where ORDER BY id; --replace_column 1 ID 3 HOST_NAME 6 TIME eval SELECT $columns FROM $table $select_where ORDER BY id; --source suite/funcs_1/datadict/datadict_priv.inc ---real_sleep 0.3 --echo #################################################################################### @@ -128,6 +150,9 @@ eval SELECT $columns FROM $table $select_where ORDER BY id; connection con100; --echo SHOW/SELECT shows only the processes (1) of the user. --echo #################################################################################### +# No need for poll routine here. +# The current state of the default session might depend on load of testing box +# but "ddicttestuser1" must not see anything of the root session. eval SHOW CREATE TABLE $table; --replace_column 1 ID 3 HOST_NAME 6 TIME eval SHOW $table; @@ -219,7 +244,7 @@ SELECT * FROM information_schema.processlist; --echo #################################################################################### ---echo 7 Revoke PROCESS privilege from anonymous user + disconnect ddicttestuser1 +--echo 7 Revoke PROCESS privilege from anonymous user --echo connection default (user=root) --echo #################################################################################### connection default; diff --git a/mysql-test/suite/funcs_1/r/processlist_priv_no_prot.result b/mysql-test/suite/funcs_1/r/processlist_priv_no_prot.result index e24dae61f17..d862b7424e0 100644 --- a/mysql-test/suite/funcs_1/r/processlist_priv_no_prot.result +++ b/mysql-test/suite/funcs_1/r/processlist_priv_no_prot.result @@ -7,9 +7,7 @@ connection default (user=root) 1.1 Create two user #################################################################################### DROP USER ddicttestuser1@'localhost'; -ERROR HY000: Operation DROP USER failed for 'ddicttestuser1'@'localhost' DROP USER ddicttestuser2@'localhost'; -ERROR HY000: Operation DROP USER failed for 'ddicttestuser2'@'localhost' CREATE USER ddicttestuser1@'localhost'; CREATE USER ddicttestuser2@'localhost'; SET PASSWORD FOR ddicttestuser1@'localhost' = PASSWORD('ddictpass'); @@ -240,7 +238,7 @@ ID ddicttestuser1 HOST_NAME information_schema Query TIME executing SELECT * FRO ID ddicttestuser1 HOST_NAME information_schema Sleep TIME NULL ID ddicttestuser1 HOST_NAME information_schema Sleep TIME NULL #################################################################################### -7 Revoke PROCESS privilege from anonymous user + disconnect ddicttestuser1 +7 Revoke PROCESS privilege from anonymous user connection default (user=root) #################################################################################### REVOKE PROCESS ON *.* FROM ''@'localhost'; diff --git a/mysql-test/suite/funcs_1/r/processlist_priv_ps.result b/mysql-test/suite/funcs_1/r/processlist_priv_ps.result index 8ec9fad75e1..56230a0f806 100644 --- a/mysql-test/suite/funcs_1/r/processlist_priv_ps.result +++ b/mysql-test/suite/funcs_1/r/processlist_priv_ps.result @@ -7,9 +7,7 @@ connection default (user=root) 1.1 Create two user #################################################################################### DROP USER ddicttestuser1@'localhost'; -ERROR HY000: Operation DROP USER failed for 'ddicttestuser1'@'localhost' DROP USER ddicttestuser2@'localhost'; -ERROR HY000: Operation DROP USER failed for 'ddicttestuser2'@'localhost' CREATE USER ddicttestuser1@'localhost'; CREATE USER ddicttestuser2@'localhost'; SET PASSWORD FOR ddicttestuser1@'localhost' = PASSWORD('ddictpass'); @@ -240,7 +238,7 @@ ID ddicttestuser1 HOST_NAME information_schema Execute TIME executing SELECT * F ID ddicttestuser1 HOST_NAME information_schema Sleep TIME NULL ID ddicttestuser1 HOST_NAME information_schema Sleep TIME NULL #################################################################################### -7 Revoke PROCESS privilege from anonymous user + disconnect ddicttestuser1 +7 Revoke PROCESS privilege from anonymous user connection default (user=root) #################################################################################### REVOKE PROCESS ON *.* FROM ''@'localhost'; diff --git a/mysql-test/suite/rpl/r/rpl_binlog_query_filter_rules.result b/mysql-test/suite/rpl/r/rpl_binlog_query_filter_rules.result new file mode 100644 index 00000000000..520d500ed7c --- /dev/null +++ b/mysql-test/suite/rpl/r/rpl_binlog_query_filter_rules.result @@ -0,0 +1,11 @@ +drop table if exists t1; +reset master; +create table t1 (a int); +insert into t1 values (1); +flush logs; +drop table t1; +*** must be 1 *** +select * from t1; +a +1 +drop table t1; diff --git a/mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result b/mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result index 8f68936f6cc..e1a90361dc9 100644 --- a/mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result +++ b/mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result @@ -520,3 +520,10 @@ INSERT INTO t7 VALUES (1, "", 1); INSERT INTO t7 VALUES (2, repeat(_utf8'a', 255), 2); Comparing tables master:test.t7 and slave:test.t7 drop table t1, t2, t3, t4, t5, t6, t7; +CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE='MYISAM' ; +INSERT INTO t1 VALUES (1), (2), (3); +UPDATE t1 SET a = 10; +ERROR 23000: Duplicate entry '10' for key 'PRIMARY' +INSERT INTO t1 VALUES (4); +Comparing tables master:test.t1 and slave:test.t1 +drop table t1; diff --git a/mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result b/mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result index 72517383cc3..fb082e8742c 100644 --- a/mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result +++ b/mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result @@ -520,3 +520,10 @@ INSERT INTO t7 VALUES (1, "", 1); INSERT INTO t7 VALUES (2, repeat(_utf8'a', 255), 2); Comparing tables master:test.t7 and slave:test.t7 drop table t1, t2, t3, t4, t5, t6, t7; +CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE='INNODB' ; +INSERT INTO t1 VALUES (1), (2), (3); +UPDATE t1 SET a = 10; +ERROR 23000: Duplicate entry '10' for key 'PRIMARY' +INSERT INTO t1 VALUES (4); +Comparing tables master:test.t1 and slave:test.t1 +drop table t1; diff --git a/mysql-test/suite/rpl/r/rpl_row_log.result b/mysql-test/suite/rpl/r/rpl_row_log.result index 1b6fce5e206..d08444ce586 100644 --- a/mysql-test/suite/rpl/r/rpl_row_log.result +++ b/mysql-test/suite/rpl/r/rpl_row_log.result @@ -7,7 +7,7 @@ start slave; include/stop_slave.inc reset master; reset slave; -reset master; +start slave; create table t1(n int not null auto_increment primary key)ENGINE=MyISAM; insert into t1 values (NULL); drop table t1; diff --git a/mysql-test/suite/rpl/r/rpl_row_log_innodb.result b/mysql-test/suite/rpl/r/rpl_row_log_innodb.result index 14d4412f6de..412f24602a8 100644 --- a/mysql-test/suite/rpl/r/rpl_row_log_innodb.result +++ b/mysql-test/suite/rpl/r/rpl_row_log_innodb.result @@ -7,7 +7,7 @@ start slave; include/stop_slave.inc reset master; reset slave; -reset master; +start slave; create table t1(n int not null auto_increment primary key)ENGINE=InnoDB; insert into t1 values (NULL); drop table t1; diff --git a/mysql-test/suite/rpl/r/rpl_stm_log.result b/mysql-test/suite/rpl/r/rpl_stm_log.result index 740dce4a03c..7c0f5547470 100644 --- a/mysql-test/suite/rpl/r/rpl_stm_log.result +++ b/mysql-test/suite/rpl/r/rpl_stm_log.result @@ -7,7 +7,7 @@ start slave; include/stop_slave.inc reset master; reset slave; -reset master; +start slave; create table t1(n int not null auto_increment primary key)ENGINE=MyISAM; insert into t1 values (NULL); drop table t1; diff --git a/mysql-test/suite/rpl/t/rpl_binlog_query_filter_rules-master.opt b/mysql-test/suite/rpl/t/rpl_binlog_query_filter_rules-master.opt new file mode 100644 index 00000000000..33632bf98e8 --- /dev/null +++ b/mysql-test/suite/rpl/t/rpl_binlog_query_filter_rules-master.opt @@ -0,0 +1 @@ +--replicate-do-db='impossible_database' diff --git a/mysql-test/suite/rpl/t/rpl_binlog_query_filter_rules.test b/mysql-test/suite/rpl/t/rpl_binlog_query_filter_rules.test new file mode 100644 index 00000000000..d8e25b244fa --- /dev/null +++ b/mysql-test/suite/rpl/t/rpl_binlog_query_filter_rules.test @@ -0,0 +1,31 @@ +# regression test for +# Bug#36099 replicate-do-db affects replaying RBR events with mysqlbinlog +# The test verifies that the slave side filtering rule does not affect +# applying of row-events on master via mysqlbinlog + +-- source include/have_log_bin.inc +-- source include/not_embedded.inc +-- source include/have_binlog_format_row.inc + +--disable_warnings +drop table if exists t1; +--enable_warnings + +reset master; + +create table t1 (a int); +insert into t1 values (1); + +flush logs; +--exec $MYSQL_BINLOG $MYSQLTEST_VARDIR/log/master-bin.000001 > $MYSQLTEST_VARDIR/tmp/bug36099.sql + +drop table t1; +--exec $MYSQL -e "source $MYSQLTEST_VARDIR/tmp/bug36099.sql" + +--echo *** must be 1 *** +select * from t1; + +# cleanup + +drop table t1; +remove_file $MYSQLTEST_VARDIR/tmp/bug36099.sql; diff --git a/mysql-test/suite/rpl/t/rpl_stm_log-slave.opt b/mysql-test/suite/rpl/t/rpl_stm_log-slave.opt index 8b137891791..203fc2287ec 100644 --- a/mysql-test/suite/rpl/t/rpl_stm_log-slave.opt +++ b/mysql-test/suite/rpl/t/rpl_stm_log-slave.opt @@ -1 +1 @@ - +--log-slave-updates diff --git a/mysql-test/suite/rpl/t/rpl_view-slave.opt b/mysql-test/suite/rpl/t/rpl_view-slave.opt deleted file mode 100644 index 79b3bf6174b..00000000000 --- a/mysql-test/suite/rpl/t/rpl_view-slave.opt +++ /dev/null @@ -1 +0,0 @@ ---replicate-ignore-table=test.foo diff --git a/mysql-test/suite/rpl_ndb/r/rpl_ndb_log.result b/mysql-test/suite/rpl_ndb/r/rpl_ndb_log.result index 8b480df8d0c..28714fe920c 100644 --- a/mysql-test/suite/rpl_ndb/r/rpl_ndb_log.result +++ b/mysql-test/suite/rpl_ndb/r/rpl_ndb_log.result @@ -7,7 +7,7 @@ start slave; include/stop_slave.inc reset master; reset slave; -reset master; +start slave; create table t1(n int not null auto_increment primary key)ENGINE=NDB; insert into t1 values (NULL); drop table t1; diff --git a/mysql-test/suite/rpl_ndb/r/rpl_row_basic_7ndb.result b/mysql-test/suite/rpl_ndb/r/rpl_row_basic_7ndb.result index 9ba0869a4d2..10c2bc94f6c 100644 --- a/mysql-test/suite/rpl_ndb/r/rpl_row_basic_7ndb.result +++ b/mysql-test/suite/rpl_ndb/r/rpl_row_basic_7ndb.result @@ -520,3 +520,10 @@ INSERT INTO t7 VALUES (1, "", 1); INSERT INTO t7 VALUES (2, repeat(_utf8'a', 255), 2); Comparing tables master:test.t7 and slave:test.t7 drop table t1, t2, t3, t4, t5, t6, t7; +CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE='NDB' ; +INSERT INTO t1 VALUES (1), (2), (3); +UPDATE t1 SET a = 10; +ERROR 23000: Duplicate entry '10' for key 'PRIMARY' +INSERT INTO t1 VALUES (4); +Comparing tables master:test.t1 and slave:test.t1 +drop table t1; diff --git a/mysql-test/t/create.test b/mysql-test/t/create.test index 2a1a780ab24..33a75147093 100644 --- a/mysql-test/t/create.test +++ b/mysql-test/t/create.test @@ -1176,6 +1176,24 @@ SHOW INDEX FROM t1; DROP TABLE t1; +# +# Bug#38821: Assert table->auto_increment_field_not_null failed in open_table() +# +CREATE TABLE t1 (a INTEGER AUTO_INCREMENT PRIMARY KEY, b INTEGER NOT NULL); +INSERT IGNORE INTO t1 (b) VALUES (5); + +CREATE TABLE IF NOT EXISTS t2 (a INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY) + SELECT a FROM t1; +--error 1062 +CREATE TABLE IF NOT EXISTS t2 (a INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY) + SELECT a FROM t1; +--error 1062 +CREATE TABLE IF NOT EXISTS t2 (a INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY) + SELECT a FROM t1; + +DROP TABLE t1, t2; + + --echo End of 5.0 tests # diff --git a/mysql-test/t/default.test b/mysql-test/t/default.test index 14aa4b02cfe..b719cb83448 100644 --- a/mysql-test/t/default.test +++ b/mysql-test/t/default.test @@ -145,5 +145,24 @@ insert into t1 values(default); drop view v1; drop table t1; +# +# Bug #39002: crash with +# INSERT ... SELECT ... ON DUPLICATE KEY UPDATE col=DEFAULT +# + +create table t1 (a int unique); +create table t2 (b int default 10); +insert into t1 (a) values (1); +insert into t2 (b) values (1); + +insert into t1 (a) select b from t2 on duplicate key update a=default; +select * from t1; + +insert into t1 (a) values (1); +insert into t1 (a) select b from t2 on duplicate key update a=default(b); +select * from t1; + +drop table t1, t2; + --echo End of 5.0 tests. diff --git a/mysql-test/t/func_regexp.test b/mysql-test/t/func_regexp.test index f3677b8f5b0..638e0bf08ee 100644 --- a/mysql-test/t/func_regexp.test +++ b/mysql-test/t/func_regexp.test @@ -64,6 +64,16 @@ drop table t1; SELECT 1 REGEXP NULL; + +# +# Bug #39021: SELECT REGEXP BINARY NULL never returns +# + +SELECT '' REGEXP BINARY NULL; +SELECT NULL REGEXP BINARY NULL; +SELECT 'A' REGEXP BINARY NULL; +SELECT "ABC" REGEXP BINARY NULL; + --echo End of 5.0 tests diff --git a/mysql-test/t/grant2.test b/mysql-test/t/grant2.test index afdd2793207..21de3e349cf 100644 --- a/mysql-test/t/grant2.test +++ b/mysql-test/t/grant2.test @@ -606,7 +606,7 @@ connection conn1; USE db1; --error ER_COLUMNACCESS_DENIED_ERROR SELECT c FROM t2; ---error ER_COLUMNACCESS_DENIED_ERROR +--error ER_TABLEACCESS_DENIED_ERROR SELECT * FROM t2; --error ER_COLUMNACCESS_DENIED_ERROR SELECT * FROM t1 JOIN t2 USING (b); diff --git a/mysql-test/t/partition_not_windows.test b/mysql-test/t/partition_not_windows.test index 333e12e2b16..ca5f1ba441e 100644 --- a/mysql-test/t/partition_not_windows.test +++ b/mysql-test/t/partition_not_windows.test @@ -3,6 +3,8 @@ --source include/have_partition.inc # DATA DIRECTORY/INDEX DIRECTORY require symbolic link support --source include/have_symlink.inc +# realpath is not compiled in when building with valgrind +--source include/not_valgrind.inc # The test for Bug 20770 is disabled on Windows due to BUG#19107; it # should be moved into partition.test once the bug has been resolved. diff --git a/mysql-test/t/skip_log_bin-master.opt b/mysql-test/t/skip_log_bin-master.opt new file mode 100644 index 00000000000..9ebccecc95e --- /dev/null +++ b/mysql-test/t/skip_log_bin-master.opt @@ -0,0 +1 @@ +--loose-skip-log-bin diff --git a/mysql-test/t/skip_log_bin.test b/mysql-test/t/skip_log_bin.test new file mode 100644 index 00000000000..6175b2cf7d3 --- /dev/null +++ b/mysql-test/t/skip_log_bin.test @@ -0,0 +1,25 @@ +# +# binlog_off.test purpose is to verify that the --skip-log-bin flag +# works correctly +# + +--disable_warnings +DROP TABLE IF EXISTS t1, t2; +--enable_warnings + +# +# Bug #38798 Assertion mysql_bin_log.is_open() failed in +# binlog_trans_log_savepos() +# Testing that there is no crash. +# Before BUG#38798, the code for CREATE...SELECT called an internal function to +# binlog the statement, even with --skip-log-bin. This caused an assertion +# to be thrown since the binlog was not open. + +set @@session.binlog_format=row; + +create table t1 (a int); +insert into t1 values (1); +create table t2 select * from t1; + +# clean-up +drop table t1, t2; diff --git a/mysql-test/t/status.test b/mysql-test/t/status.test index bc629e9c86d..8bd9ee26b26 100644 --- a/mysql-test/t/status.test +++ b/mysql-test/t/status.test @@ -261,4 +261,37 @@ drop function f1; show status like 'Com%function'; +# +# Bug#37908: Skipped access right check caused server crash. +# +connect (root, localhost, root,,test); +connection root; +--disable_warnings +create database db37908; +--enable_warnings +create table db37908.t1(f1 int); +insert into db37908.t1 values(1); +grant usage,execute on test.* to mysqltest_1@localhost; +delimiter |; +create procedure proc37908() begin select 1; end | +create function func37908() returns int sql security invoker + return (select * from db37908.t1 limit 1)| +delimiter ;| + +connect (user1,localhost,mysqltest_1,,test); +connection user1; + +--error 1142 +select * from db37908.t1; +--error 1142 +show status where variable_name ='uptime' and 2 in (select * from db37908.t1); +--error 1142 +show procedure status where name ='proc37908' and 1 in (select f1 from db37908.t1); +--error 1142 +show function status where name ='func37908' and 1 in (select func37908()); + +connection root; +drop database db37908; +drop procedure proc37908; +drop function func37908; # End of 5.1 tests diff --git a/mysql-test/t/type_datetime.test b/mysql-test/t/type_datetime.test index 4fdd96b8729..eb1b7bde844 100644 --- a/mysql-test/t/type_datetime.test +++ b/mysql-test/t/type_datetime.test @@ -388,6 +388,22 @@ where id in (select id from t2 as x1 where (t2.cur_date is null)); drop table t1,t2; + +# +# Bug #37526: asymertic operator <=> in trigger +# +SELECT + CAST('NULL' AS DATE) <=> CAST('2008-01-01' AS DATE) n1, + CAST('2008-01-01' AS DATE) <=> CAST('NULL' AS DATE) n2, + CAST('NULL' AS DATE) <=> CAST('NULL' AS DATE) n3, + CAST('NULL' AS DATE) <> CAST('2008-01-01' AS DATE) n4, + CAST('2008-01-01' AS DATE) <> CAST('NULL' AS DATE) n5, + CAST('NULL' AS DATE) <> CAST('NULL' AS DATE) n6, + CAST('NULL' AS DATE) < CAST('2008-01-01' AS DATE) n7, + CAST('2008-01-01' AS DATE) < CAST('NULL' AS DATE) n8, + CAST('NULL' AS DATE) < CAST('NULL' AS DATE) n9; + + --echo End of 5.0 tests # # Test of storing datetime into date fields diff --git a/mysql-test/t/type_set.test b/mysql-test/t/type_set.test index e98555e137b..a851d116743 100644 --- a/mysql-test/t/type_set.test +++ b/mysql-test/t/type_set.test @@ -75,4 +75,23 @@ INSERT INTO t1 VALUES(9223372036854775808); SELECT * FROM t1; DROP TABLE t1; +# +# Bug #38701: Crash in String::append when inserting duplicate empty strings +# an uft8 SET col +# + +CREATE TABLE t1 ( + set_unique_utf8 set ('a','b','c','d','e','f','g','h','i','j','k','l', + 'm','n','o','p','q','r','s','t','u','v','w','x', + 'y','z') CHARACTER SET utf8, + unique (set_unique_utf8) +); + +INSERT INTO t1 ( set_unique_utf8 ) VALUES ( '' ); +--error ER_DUP_ENTRY +INSERT INTO t1 ( set_unique_utf8 ) VALUES ( '' ); + +DROP TABLE t1; + + --echo End of 5.0 tests diff --git a/mysql-test/t/view_grant.test b/mysql-test/t/view_grant.test index cbc66300173..4e8d97e4444 100644 --- a/mysql-test/t/view_grant.test +++ b/mysql-test/t/view_grant.test @@ -1219,3 +1219,80 @@ DROP VIEW v1; DROP TABLE t1; --echo End of 5.1 tests. + +# +# Bug#36086: SELECT * from views don't check column grants +# +CREATE USER mysqluser1@localhost; +CREATE DATABASE mysqltest1; + +USE mysqltest1; + +CREATE TABLE t1 ( a INT, b INT ); +CREATE TABLE t2 ( a INT, b INT ); + +CREATE VIEW v1 AS SELECT a, b FROM t1; + +GRANT SELECT( a ) ON v1 TO mysqluser1@localhost; +GRANT UPDATE( b ) ON t2 TO mysqluser1@localhost; + +--connect (connection1, localhost, mysqluser1, , test) + +--error ER_TABLEACCESS_DENIED_ERROR +SELECT * FROM mysqltest1.v1; + +--error ER_TABLEACCESS_DENIED_ERROR +CREATE VIEW v1 AS SELECT * FROM mysqltest1.t2; + +--disconnect connection1 + +--connection default + +DROP TABLE t1, t2; +DROP VIEW v1; +DROP DATABASE mysqltest1; +DROP USER mysqluser1@localhost; + +# +# Bug#35600: Security breach via view, I_S table and prepared +# statement/stored procedure +# +CREATE USER mysqluser1@localhost; +CREATE DATABASE mysqltest1; + +USE mysqltest1; + +CREATE VIEW v1 AS SELECT * FROM information_schema.tables LIMIT 1; +CREATE ALGORITHM = TEMPTABLE VIEW v2 AS SELECT 1 AS A; + +CREATE VIEW test.v3 AS SELECT 1 AS a; + +--connection default +GRANT SELECT ON mysqltest1.* to mysqluser1@localhost; +GRANT ALL ON test.* TO mysqluser1@localhost; + +--connect (connection1, localhost, mysqluser1, , test) +PREPARE stmt_v1 FROM "SELECT * FROM mysqltest1.v1"; +PREPARE stmt_v2 FROM "SELECT * FROM mysqltest1.v2"; + +--connection default +REVOKE SELECT ON mysqltest1.* FROM mysqluser1@localhost; + +--connection connection1 + +--error ER_TABLEACCESS_DENIED_ERROR +EXECUTE stmt_v1; +--error ER_TABLEACCESS_DENIED_ERROR +EXECUTE stmt_v2; +--disconnect connection1 + +--connect (connection2, localhost, mysqluser1,,) +PREPARE stmt FROM "SELECT a FROM v3"; +EXECUTE stmt; +--disconnect connection2 + +--connection default +DROP VIEW v1, v2; +DROP DATABASE mysqltest1; +DROP VIEW test.v3; +DROP USER mysqluser1@localhost; diff --git a/scripts/mysql_install_db.sh b/scripts/mysql_install_db.sh index 4e5ca7305f8..5a2409eeb6f 100644 --- a/scripts/mysql_install_db.sh +++ b/scripts/mysql_install_db.sh @@ -339,6 +339,7 @@ mysqld_bootstrap="${MYSQLD_BOOTSTRAP-$mysqld}" mysqld_install_cmd_line="$mysqld_bootstrap $defaults $mysqld_opt --bootstrap \ --basedir=$basedir --datadir=$ldata --log-warnings=0 --loose-skip-innodb \ --loose-skip-ndbcluster $args --max_allowed_packet=8M \ + --default-storage-engine=myisam \ --net_buffer_length=16K" # Create the system and help tables by passing them to "mysqld --bootstrap" diff --git a/server-tools/instance-manager/mysqlmanager.vcproj b/server-tools/instance-manager/mysqlmanager.vcproj deleted file mode 100644 index a38565fc1f3..00000000000 --- a/server-tools/instance-manager/mysqlmanager.vcproj +++ /dev/null @@ -1,382 +0,0 @@ -<?xml version="1.0" encoding="Windows-1252"?> -<VisualStudioProject - ProjectType="Visual C++" - Version="7.10" - Name="mysqlmanager" - ProjectGUID="{6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}" - Keyword="Win32Proj"> - <Platforms> - <Platform - Name="Win32"/> - </Platforms> - <Configurations> - <Configuration - Name="Debug|Win32" - OutputDirectory=".\debug_obj" - IntermediateDirectory=".\debug_obj" - ConfigurationType="1" - CharacterSet="2"> - <Tool - Name="VCCLCompilerTool" - Optimization="0" - OptimizeForProcessor="2" - AdditionalIncludeDirectories="..\..\include,../../extra/yassl/include" - PreprocessorDefinitions="MYSQL_INSTANCE_MANAGER;MYSQL_SERVER;_DEBUG;SAFEMALLOC;SAFE_MUTEX;_WINDOWS;CONSOLE" - MinimalRebuild="TRUE" - ExceptionHandling="FALSE" - BasicRuntimeChecks="3" - RuntimeLibrary="1" - UsePrecompiledHeader="0" - WarningLevel="3" - Detect64BitPortabilityProblems="TRUE" - DebugInformationFormat="4"/> - <Tool - Name="VCCustomBuildTool"/> - <Tool - Name="VCLinkerTool" - AdditionalDependencies="wsock32.lib" - OutputFile=".\debug/mysqlmanager.exe" - LinkIncremental="1" - GenerateDebugInformation="TRUE" - ProgramDatabaseFile=".\debug/mysqlmanager.pdb" - GenerateMapFile="TRUE" - MapFileName=".\debug/mysqlmanager.map" - SubSystem="1" - TargetMachine="1"/> - <Tool - Name="VCMIDLTool"/> - <Tool - Name="VCPostBuildEventTool"/> - <Tool - Name="VCPreBuildEventTool"/> - <Tool - Name="VCPreLinkEventTool"/> - <Tool - Name="VCResourceCompilerTool"/> - <Tool - Name="VCWebServiceProxyGeneratorTool"/> - <Tool - Name="VCXMLDataGeneratorTool"/> - <Tool - Name="VCWebDeploymentTool"/> - <Tool - Name="VCManagedWrapperGeneratorTool"/> - <Tool - Name="VCAuxiliaryManagedWrapperGeneratorTool"/> - </Configuration> - <Configuration - Name="Release|Win32" - OutputDirectory=".\release_obj" - IntermediateDirectory=".\release_obj" - ConfigurationType="1" - CharacterSet="2"> - <Tool - Name="VCCLCompilerTool" - Optimization="2" - InlineFunctionExpansion="1" - OptimizeForProcessor="2" - AdditionalIncludeDirectories="..\..\include,../../extra/yassl/include" - PreprocessorDefinitions="MYSQL_INSTANCE_MANAGER;MYSQL_SERVER;_WINDOWS;CONSOLE" - ExceptionHandling="FALSE" - RuntimeLibrary="0" - UsePrecompiledHeader="0" - WarningLevel="3" - Detect64BitPortabilityProblems="TRUE" - DebugInformationFormat="3"/> - <Tool - Name="VCCustomBuildTool"/> - <Tool - Name="VCLinkerTool" - AdditionalDependencies="wsock32.lib" - OutputFile=".\release/mysqlmanager.exe" - LinkIncremental="1" - GenerateDebugInformation="TRUE" - ProgramDatabaseFile=".\release/mysqlmanager.pdb" - GenerateMapFile="TRUE" - MapFileName=".\release/mysqlmanager.map" - SubSystem="1" - OptimizeReferences="2" - EnableCOMDATFolding="2" - TargetMachine="1"/> - <Tool - Name="VCMIDLTool"/> - <Tool - Name="VCPostBuildEventTool"/> - <Tool - Name="VCPreBuildEventTool"/> - <Tool - Name="VCPreLinkEventTool"/> - <Tool - Name="VCResourceCompilerTool"/> - <Tool - Name="VCWebServiceProxyGeneratorTool"/> - <Tool - Name="VCXMLDataGeneratorTool"/> - <Tool - Name="VCWebDeploymentTool"/> - <Tool - Name="VCManagedWrapperGeneratorTool"/> - <Tool - Name="VCAuxiliaryManagedWrapperGeneratorTool"/> - </Configuration> - </Configurations> - <References> - </References> - <Files> - <Filter - Name="Source Files" - Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" - UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> - <File - RelativePath=".\buffer.cpp"> - </File> - <File - RelativePath="..\..\sql\client.c"> - <FileConfiguration - Name="Debug|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - <FileConfiguration - Name="Release|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - </File> - <File - RelativePath=".\command.cpp"> - </File> - <File - RelativePath=".\commands.cpp"> - </File> - <File - RelativePath="..\..\libmysql\get_password.c"> - <FileConfiguration - Name="Debug|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - <FileConfiguration - Name="Release|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - </File> - <File - RelativePath=".\guardian.cpp"> - </File> - <File - RelativePath=".\IMService.cpp"> - </File> - <File - RelativePath=".\instance.cpp"> - </File> - <File - RelativePath=".\instance_map.cpp"> - </File> - <File - RelativePath=".\instance_options.cpp"> - </File> - <File - RelativePath=".\listener.cpp"> - </File> - <File - RelativePath=".\log.cpp"> - </File> - <File - RelativePath=".\manager.cpp"> - </File> - <File - RelativePath=".\messages.cpp"> - </File> - <File - RelativePath="..\..\sql\mini_client_errors.c"> - <FileConfiguration - Name="Debug|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - <FileConfiguration - Name="Release|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - </File> - <File - RelativePath=".\mysql_connection.cpp"> - <FileConfiguration - Name="Debug|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - <FileConfiguration - Name="Release|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - </File> - <File - RelativePath=".\mysqlmanager.cpp"> - </File> - <File - RelativePath="..\..\sql\net_serv.cpp"> - <FileConfiguration - Name="Debug|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - <FileConfiguration - Name="Release|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - </File> - <File - RelativePath=".\options.cpp"> - </File> - <File - RelativePath="..\..\sql\pack.c"> - <FileConfiguration - Name="Debug|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - <FileConfiguration - Name="Release|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - </File> - <File - RelativePath=".\parse.cpp"> - </File> - <File - RelativePath=".\parse_output.cpp"> - </File> - <File - RelativePath="..\..\sql\password.c"> - <FileConfiguration - Name="Debug|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - <FileConfiguration - Name="Release|Win32"> - <Tool - Name="VCCLCompilerTool" - ObjectFile="$(IntDir)/$(InputName)1.obj"/> - </FileConfiguration> - </File> - <File - RelativePath=".\priv.cpp"> - </File> - <File - RelativePath=".\protocol.cpp"> - </File> - <File - RelativePath="..\..\sql\sql_state.c"> - </File> - <File - RelativePath=".\thread_registry.cpp"> - </File> - <File - RelativePath=".\user_map.cpp"> - </File> - <File - RelativePath=".\WindowsService.cpp"> - </File> - </Filter> - <Filter - Name="Header Files" - Filter="h;hpp;hxx;hm;inl;inc;xsd" - UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> - <File - RelativePath=".\buffer.h"> - </File> - <File - RelativePath=".\command.h"> - </File> - <File - RelativePath=".\commands.h"> - </File> - <File - RelativePath=".\factory.h"> - </File> - <File - RelativePath=".\guardian.h"> - </File> - <File - RelativePath=".\IMService.h"> - </File> - <File - RelativePath=".\instance.h"> - </File> - <File - RelativePath=".\instance_map.h"> - </File> - <File - RelativePath=".\instance_options.h"> - </File> - <File - RelativePath=".\listener.h"> - </File> - <File - RelativePath=".\log.h"> - </File> - <File - RelativePath=".\manager.h"> - </File> - <File - RelativePath=".\messages.h"> - </File> - <File - RelativePath=".\mysql_connection.h"> - </File> - <File - RelativePath=".\mysql_manager_error.h"> - </File> - <File - RelativePath=".\options.h"> - </File> - <File - RelativePath=".\parse.h"> - </File> - <File - RelativePath=".\parse_output.h"> - </File> - <File - RelativePath=".\portability.h"> - </File> - <File - RelativePath=".\priv.h"> - </File> - <File - RelativePath=".\protocol.h"> - </File> - <File - RelativePath=".\thread_registry.h"> - </File> - <File - RelativePath=".\user_map.h"> - </File> - <File - RelativePath=".\WindowsService.h"> - </File> - </Filter> - </Files> - <Globals> - </Globals> -</VisualStudioProject> diff --git a/sql/handler.cc b/sql/handler.cc index 6ec90ae0703..e7cc5b82347 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -2496,7 +2496,7 @@ void handler::print_keydup_error(uint key_nr, const char *msg) str.append(STRING_WITH_LEN("...")); } my_printf_error(ER_DUP_ENTRY, msg, - MYF(0), str.c_ptr(), table->key_info[key_nr].name); + MYF(0), str.c_ptr_safe(), table->key_info[key_nr].name); } } @@ -2564,7 +2564,7 @@ void handler::print_error(int error, myf errflag) str.append(STRING_WITH_LEN("...")); } my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table_share->table_name.str, - str.c_ptr(), key_nr+1); + str.c_ptr_safe(), key_nr+1); DBUG_VOID_RETURN; } textno= ER_DUP_KEY; diff --git a/sql/item.cc b/sql/item.cc index 3f41c7211c8..951336cce24 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -4120,16 +4120,8 @@ bool Item_field::fix_fields(THD *thd, Item **reference) if (any_privileges) { char *db, *tab; - if (cached_table->view) - { - db= cached_table->view_db.str; - tab= cached_table->view_name.str; - } - else - { - db= cached_table->db; - tab= cached_table->table_name; - } + db= cached_table->get_db_name(); + tab= cached_table->get_table_name(); if (!(have_privileges= (get_column_grant(thd, &field->table->grant, db, tab, field_name) & VIEW_ANY_ACL))) @@ -6210,6 +6202,13 @@ Item *Item_default_value::transform(Item_transformer transformer, uchar *args) { DBUG_ASSERT(!current_thd->is_stmt_prepare()); + /* + If the value of arg is NULL, then this object represents a constant, + so further transformation is unnecessary (and impossible). + */ + if (!arg) + return 0; + Item *new_item= arg->transform(transformer, args); if (!new_item) return 0; diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc index 64a2049a37b..bd6065c9403 100644 --- a/sql/item_cmpfunc.cc +++ b/sql/item_cmpfunc.cc @@ -1029,19 +1029,24 @@ get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg, 1 if items are equal or both are null 0 otherwise If is_nulls_eq is FALSE: - -1 a < b or one of items is null + -1 a < b or at least one item is null 0 a == b 1 a > b + See the table: + is_nulls_eq | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | + a_is_null | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | + b_is_null | 1 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | + result | 1 | 0 | 0 |0/1|-1 |-1 |-1 |-1/0/1| */ int Arg_comparator::compare_datetime() { - bool is_null= FALSE; + bool a_is_null, b_is_null; ulonglong a_value, b_value; /* Get DATE/DATETIME/TIME value of the 'a' item. */ - a_value= (*get_value_func)(thd, &a, &a_cache, *b, &is_null); - if (!is_nulls_eq && is_null) + a_value= (*get_value_func)(thd, &a, &a_cache, *b, &a_is_null); + if (!is_nulls_eq && a_is_null) { if (owner) owner->null_value= 1; @@ -1049,14 +1054,15 @@ int Arg_comparator::compare_datetime() } /* Get DATE/DATETIME/TIME value of the 'b' item. */ - b_value= (*get_value_func)(thd, &b, &b_cache, *a, &is_null); - if (is_null) + b_value= (*get_value_func)(thd, &b, &b_cache, *a, &b_is_null); + if (a_is_null || b_is_null) { if (owner) owner->null_value= is_nulls_eq ? 0 : 1; - return is_nulls_eq ? 1 : -1; + return is_nulls_eq ? (a_is_null == b_is_null) : -1; } + /* Here we have two not-NULL values. */ if (owner) owner->null_value= 0; @@ -4460,8 +4466,20 @@ void Item_func_like::cleanup() #ifdef USE_REGEX -bool -Item_func_regex::regcomp(bool send_error) +/** + @brief Compile regular expression. + + @param[in] send_error send error message if any. + + @details Make necessary character set conversion then + compile regular expression passed in the args[1]. + + @retval 0 success. + @retval 1 error occurred. + @retval -1 given null regular expression. + */ + +int Item_func_regex::regcomp(bool send_error) { char buff[MAX_FIELD_WIDTH]; String tmp(buff,sizeof(buff),&my_charset_bin); @@ -4469,12 +4487,12 @@ Item_func_regex::regcomp(bool send_error) int error; if (args[1]->null_value) - return TRUE; + return -1; if (regex_compiled) { if (!stringcmp(res, &prev_regexp)) - return FALSE; + return 0; prev_regexp.copy(*res); my_regfree(&preg); regex_compiled= 0; @@ -4486,7 +4504,7 @@ Item_func_regex::regcomp(bool send_error) uint dummy_errors; if (conv.copy(res->ptr(), res->length(), res->charset(), regex_lib_charset, &dummy_errors)) - return TRUE; + return 1; res= &conv; } @@ -4498,10 +4516,10 @@ Item_func_regex::regcomp(bool send_error) (void) my_regerror(error, &preg, buff, sizeof(buff)); my_error(ER_REGEXP_ERROR, MYF(0), buff); } - return TRUE; + return 1; } regex_compiled= 1; - return FALSE; + return 0; } @@ -4539,13 +4557,14 @@ Item_func_regex::fix_fields(THD *thd, Item **ref) const_item_cache=args[0]->const_item() && args[1]->const_item(); if (!regex_compiled && args[1]->const_item()) { - if (args[1]->null_value) + int comp_res= regcomp(TRUE); + if (comp_res == -1) { // Will always return NULL maybe_null=1; fixed= 1; return FALSE; } - if (regcomp(TRUE)) + else if (comp_res) return TRUE; regex_is_const= 1; maybe_null= args[0]->maybe_null; diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index 0166a18029d..2bf39e6da8d 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -1401,7 +1401,7 @@ class Item_func_regex :public Item_bool_func CHARSET_INFO *regex_lib_charset; int regex_lib_flags; String conv; - bool regcomp(bool send_error); + int regcomp(bool send_error); public: Item_func_regex(Item *a,Item *b) :Item_bool_func(a,b), regex_compiled(0),regex_is_const(0) {} diff --git a/sql/log.cc b/sql/log.cc index f459b4349cb..8f46728bcbd 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -1421,6 +1421,7 @@ binlog_end_trans(THD *thd, binlog_trx_data *trx_data, If rolling back a statement in a transaction, we truncate the transaction cache to remove the statement. */ + thd->binlog_remove_pending_rows_event(TRUE); if (all || !(thd->options & (OPTION_BEGIN | OPTION_NOT_AUTOCOMMIT))) trx_data->reset(); else // ...statement @@ -3768,6 +3769,31 @@ THD::binlog_set_pending_rows_event(Rows_log_event* ev) } +/** + Remove the pending rows event, discarding any outstanding rows. + + If there is no pending rows event available, this is effectively a + no-op. + */ +int +MYSQL_BIN_LOG::remove_pending_rows_event(THD *thd) +{ + DBUG_ENTER(__FUNCTION__); + + binlog_trx_data *const trx_data= + (binlog_trx_data*) thd_get_ha_data(thd, binlog_hton); + + DBUG_ASSERT(trx_data); + + if (Rows_log_event* pending= trx_data->pending()) + { + delete pending; + trx_data->set_pending(NULL); + } + + DBUG_RETURN(0); +} + /* Moves the last bunch of rows from the pending Rows event to the binlog (either cached binlog if transaction, or disk binlog). Sets a new pending diff --git a/sql/log.h b/sql/log.h index b1a3274b60e..fe66dd1a1e9 100644 --- a/sql/log.h +++ b/sql/log.h @@ -311,6 +311,7 @@ public: void update_table_map_version() { ++m_table_map_version; } int flush_and_set_pending_rows_event(THD *thd, Rows_log_event* event); + int remove_pending_rows_event(THD *thd); #endif /* !defined(MYSQL_CLIENT) */ void reset_bytes_written() diff --git a/sql/log_event.cc b/sql/log_event.cc index c3a7f9cf6e5..1547c999eea 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -7843,8 +7843,9 @@ int Table_map_log_event::do_apply_event(Relay_log_info const *rli) int error= 0; - if (!rpl_filter->db_ok(table_list->db) || - (rpl_filter->is_on() && !rpl_filter->tables_ok("", table_list))) + if (rli->sql_thd->slave_thread /* filtering is for slave only */ && + (!rpl_filter->db_ok(table_list->db) || + (rpl_filter->is_on() && !rpl_filter->tables_ok("", table_list)))) { my_free(memory, MYF(MY_WME)); } diff --git a/sql/mysql_priv.h.pp b/sql/mysql_priv.h.pp new file mode 100644 index 00000000000..8bb31f64587 --- /dev/null +++ b/sql/mysql_priv.h.pp @@ -0,0 +1,10978 @@ +#include <my_global.h> +#include <my_config.h> +#include <pthread.h> +#include <stdio.h> +#include <stdlib.h> +#include <stddef.h> +#include <math.h> +#include <limits.h> +#include <float.h> +#include <sys/types.h> +#include <fcntl.h> +#include <sys/timeb.h> +#include <sys/time.h> +#include <time.h> +#include <unistd.h> +#include <alloca.h> +#include <errno.h> +#include <crypt.h> +#include <assert.h> +#include <my_attribute.h> +int __cxa_pure_virtual () __attribute__ ((weak)); +#include <my_dbug.h> +struct _db_code_state_; +extern int _db_keyword_(struct _db_code_state_ *cs, const char *keyword); +extern int _db_strict_keyword_(const char *keyword); +extern int _db_explain_(struct _db_code_state_ *cs, char *buf, size_t len); +extern int _db_explain_init_(char *buf, size_t len); +extern void _db_setjmp_(void); +extern void _db_longjmp_(void); +extern void _db_process_(const char *name); +extern void _db_push_(const char *control); +extern void _db_pop_(void); +extern void _db_set_(struct _db_code_state_ *cs, const char *control); +extern void _db_set_init_(const char *control); +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_ (const char *format,...) + __attribute__((format(printf, 1, 2))); +extern void _db_dump_(uint _line_,const char *keyword, + const unsigned char *memory, size_t length); +extern void _db_end_(void); +extern void _db_lock_file_(void); +extern void _db_unlock_file_(void); +extern FILE *_db_fp_(void); +typedef int File; +typedef int my_socket; +typedef void (*sig_return)(); +typedef char pchar; +typedef char puchar; +typedef char pbool; +typedef short pshort; +typedef float pfloat; +typedef int (*qsort_cmp)(const void *,const void *); +typedef int (*qsort_cmp2)(void*, const void *,const void *); +#include <sys/socket.h> +typedef socklen_t size_socket; +typedef long my_ptrdiff_t; +typedef unsigned char uchar; +typedef signed char int8; +typedef unsigned char uint8; +typedef short int16; +typedef unsigned short uint16; +typedef int int32; +typedef unsigned int uint32; +typedef unsigned long long int ulonglong; +typedef long long int longlong; +typedef longlong int64; +typedef ulonglong uint64; +typedef unsigned long long my_ulonglong; +typedef int intptr; +typedef ulonglong my_off_t; +typedef off_t os_off_t; +typedef uint8 int7; +typedef short int15; +typedef int myf; +typedef char my_bool; +typedef char bool; +typedef union { + double v; + long m[2]; +} doubleget_union; +#include <dlfcn.h> +#include <mysql_version.h> +#include <mysql_embed.h> +#include <my_sys.h> +#include <my_pthread.h> +#include <pthread.h> +#include <sched.h> +extern int my_pthread_getprio(pthread_t thread_id); +typedef void *(* pthread_handler)(void *); +extern void my_pthread_setprio(pthread_t thread_id,int prior); +extern void my_pthread_attr_setprio(pthread_attr_t *attr, int priority); +typedef struct st_safe_mutex_t +{ + pthread_mutex_t global,mutex; + const char *file; + uint line,count; + pthread_t thread; +} safe_mutex_t; +int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr, + const char *file, uint line); +int safe_mutex_lock(safe_mutex_t *mp, my_bool try_lock, const char *file, uint line); +int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line); +int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line); +int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file, + uint line); +int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp, + struct timespec *abstime, const char *file, uint line); +void safe_mutex_global_init(void); +void safe_mutex_end(FILE *file); +typedef ulong my_thread_id; +extern my_bool my_thread_global_init(void); +extern void my_thread_global_end(void); +extern my_bool my_thread_init(void); +extern void my_thread_end(void); +extern const char *my_thread_name(void); +extern my_thread_id my_thread_dbug_id(void); +extern int pthread_no_free(void *); +extern int pthread_dummy(int); +struct st_my_thread_var +{ + int thr_errno; + pthread_cond_t suspend; + pthread_mutex_t mutex; + pthread_mutex_t * volatile current_mutex; + pthread_cond_t * volatile current_cond; + pthread_t pthread_self; + my_thread_id id; + int cmp_length; + int volatile abort; + my_bool init; + struct st_my_thread_var *next,**prev; + void *opt_info; + void *dbug; + char name[10 +1]; +}; +extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const)); +extern uint my_thread_end_wait_time; +extern uint thd_lib_detected; +#include <m_ctype.h> +#include <my_attribute.h> +typedef struct unicase_info_st +{ + uint16 toupper; + uint16 tolower; + uint16 sort; +} MY_UNICASE_INFO; +extern MY_UNICASE_INFO *my_unicase_default[256]; +extern MY_UNICASE_INFO *my_unicase_turkish[256]; +typedef struct uni_ctype_st +{ + uchar pctype; + uchar *ctype; +} MY_UNI_CTYPE; +extern MY_UNI_CTYPE my_uni_ctype[256]; +typedef struct my_uni_idx_st +{ + uint16 from; + uint16 to; + uchar *tab; +} MY_UNI_IDX; +typedef struct +{ + uint beg; + uint end; + uint mb_len; +} my_match_t; +enum my_lex_states +{ + MY_LEX_START, MY_LEX_CHAR, MY_LEX_IDENT, + MY_LEX_IDENT_SEP, MY_LEX_IDENT_START, + MY_LEX_REAL, MY_LEX_HEX_NUMBER, MY_LEX_BIN_NUMBER, + MY_LEX_CMP_OP, MY_LEX_LONG_CMP_OP, MY_LEX_STRING, MY_LEX_COMMENT, MY_LEX_END, + MY_LEX_OPERATOR_OR_IDENT, MY_LEX_NUMBER_IDENT, MY_LEX_INT_OR_REAL, + MY_LEX_REAL_OR_POINT, MY_LEX_BOOL, MY_LEX_EOL, MY_LEX_ESCAPE, + MY_LEX_LONG_COMMENT, MY_LEX_END_LONG_COMMENT, MY_LEX_SEMICOLON, + MY_LEX_SET_VAR, MY_LEX_USER_END, MY_LEX_HOSTNAME, MY_LEX_SKIP, + MY_LEX_USER_VARIABLE_DELIMITER, MY_LEX_SYSTEM_VAR, + MY_LEX_IDENT_OR_KEYWORD, + MY_LEX_IDENT_OR_HEX, MY_LEX_IDENT_OR_BIN, MY_LEX_IDENT_OR_NCHAR, + MY_LEX_STRING_OR_DELIMITER +}; +struct charset_info_st; +typedef struct my_collation_handler_st +{ + my_bool (*init)(struct charset_info_st *, void *(*alloc)(size_t)); + int (*strnncoll)(struct charset_info_st *, + const uchar *, size_t, const uchar *, size_t, my_bool); + int (*strnncollsp)(struct charset_info_st *, + const uchar *, size_t, const uchar *, size_t, + my_bool diff_if_only_endspace_difference); + size_t (*strnxfrm)(struct charset_info_st *, + uchar *, size_t, const uchar *, size_t); + size_t (*strnxfrmlen)(struct charset_info_st *, size_t); + my_bool (*like_range)(struct charset_info_st *, + const char *s, size_t s_length, + pchar w_prefix, pchar w_one, pchar w_many, + size_t res_length, + char *min_str, char *max_str, + size_t *min_len, size_t *max_len); + int (*wildcmp)(struct charset_info_st *, + const char *str,const char *str_end, + const char *wildstr,const char *wildend, + int escape,int w_one, int w_many); + int (*strcasecmp)(struct charset_info_st *, const char *, const char *); + uint (*instr)(struct charset_info_st *, + const char *b, size_t b_length, + const char *s, size_t s_length, + my_match_t *match, uint nmatch); + void (*hash_sort)(struct charset_info_st *cs, const uchar *key, size_t len, + ulong *nr1, ulong *nr2); + my_bool (*propagate)(struct charset_info_st *cs, const uchar *str, size_t len); +} MY_COLLATION_HANDLER; +extern MY_COLLATION_HANDLER my_collation_mb_bin_handler; +extern MY_COLLATION_HANDLER my_collation_8bit_bin_handler; +extern MY_COLLATION_HANDLER my_collation_8bit_simple_ci_handler; +extern MY_COLLATION_HANDLER my_collation_ucs2_uca_handler; +typedef int (*my_charset_conv_mb_wc)(struct charset_info_st *, ulong *, + const uchar *, const uchar *); +typedef int (*my_charset_conv_wc_mb)(struct charset_info_st *, ulong, + uchar *, uchar *); +typedef size_t (*my_charset_conv_case)(struct charset_info_st *, + char *, size_t, char *, size_t); +typedef struct my_charset_handler_st +{ + my_bool (*init)(struct charset_info_st *, void *(*alloc)(size_t)); + uint (*ismbchar)(struct charset_info_st *, const char *, const char *); + uint (*mbcharlen)(struct charset_info_st *, uint c); + size_t (*numchars)(struct charset_info_st *, const char *b, const char *e); + size_t (*charpos)(struct charset_info_st *, const char *b, const char *e, + size_t pos); + size_t (*well_formed_len)(struct charset_info_st *, + const char *b,const char *e, + size_t nchars, int *error); + size_t (*lengthsp)(struct charset_info_st *, const char *ptr, size_t length); + size_t (*numcells)(struct charset_info_st *, const char *b, const char *e); + my_charset_conv_mb_wc mb_wc; + my_charset_conv_wc_mb wc_mb; + int (*ctype)(struct charset_info_st *cs, int *ctype, + const uchar *s, const uchar *e); + size_t (*caseup_str)(struct charset_info_st *, char *); + size_t (*casedn_str)(struct charset_info_st *, char *); + my_charset_conv_case caseup; + my_charset_conv_case casedn; + size_t (*snprintf)(struct charset_info_st *, char *to, size_t n, + const char *fmt, + ...) __attribute__((format(printf, 4, 5))); + size_t (*long10_to_str)(struct charset_info_st *, char *to, size_t n, + int radix, long int val); + size_t (*longlong10_to_str)(struct charset_info_st *, char *to, size_t n, + int radix, longlong val); + void (*fill)(struct charset_info_st *, char *to, size_t len, int fill); + long (*strntol)(struct charset_info_st *, const char *s, size_t l, + int base, char **e, int *err); + ulong (*strntoul)(struct charset_info_st *, const char *s, size_t l, + int base, char **e, int *err); + longlong (*strntoll)(struct charset_info_st *, const char *s, size_t l, + int base, char **e, int *err); + ulonglong (*strntoull)(struct charset_info_st *, const char *s, size_t l, + int base, char **e, int *err); + double (*strntod)(struct charset_info_st *, char *s, size_t l, char **e, + int *err); + longlong (*strtoll10)(struct charset_info_st *cs, + const char *nptr, char **endptr, int *error); + ulonglong (*strntoull10rnd)(struct charset_info_st *cs, + const char *str, size_t length, + int unsigned_fl, + char **endptr, int *error); + size_t (*scan)(struct charset_info_st *, const char *b, const char *e, + int sq); +} MY_CHARSET_HANDLER; +extern MY_CHARSET_HANDLER my_charset_8bit_handler; +extern MY_CHARSET_HANDLER my_charset_ucs2_handler; +typedef struct charset_info_st +{ + uint number; + uint primary_number; + uint binary_number; + uint state; + const char *csname; + const char *name; + const char *comment; + const char *tailoring; + uchar *ctype; + uchar *to_lower; + uchar *to_upper; + uchar *sort_order; + uint16 *contractions; + uint16 **sort_order_big; + uint16 *tab_to_uni; + MY_UNI_IDX *tab_from_uni; + MY_UNICASE_INFO **caseinfo; + uchar *state_map; + uchar *ident_map; + uint strxfrm_multiply; + uchar caseup_multiply; + uchar casedn_multiply; + uint mbminlen; + uint mbmaxlen; + uint16 min_sort_char; + uint16 max_sort_char; + uchar pad_char; + my_bool escape_with_backslash_is_dangerous; + MY_CHARSET_HANDLER *cset; + MY_COLLATION_HANDLER *coll; +} CHARSET_INFO; +extern CHARSET_INFO my_charset_bin; +extern CHARSET_INFO my_charset_big5_chinese_ci; +extern CHARSET_INFO my_charset_big5_bin; +extern CHARSET_INFO my_charset_cp932_japanese_ci; +extern CHARSET_INFO my_charset_cp932_bin; +extern CHARSET_INFO my_charset_eucjpms_japanese_ci; +extern CHARSET_INFO my_charset_eucjpms_bin; +extern CHARSET_INFO my_charset_euckr_korean_ci; +extern CHARSET_INFO my_charset_euckr_bin; +extern CHARSET_INFO my_charset_gb2312_chinese_ci; +extern CHARSET_INFO my_charset_gb2312_bin; +extern CHARSET_INFO my_charset_gbk_chinese_ci; +extern CHARSET_INFO my_charset_gbk_bin; +extern CHARSET_INFO my_charset_latin1; +extern CHARSET_INFO my_charset_latin1_german2_ci; +extern CHARSET_INFO my_charset_latin1_bin; +extern CHARSET_INFO my_charset_latin2_czech_ci; +extern CHARSET_INFO my_charset_sjis_japanese_ci; +extern CHARSET_INFO my_charset_sjis_bin; +extern CHARSET_INFO my_charset_tis620_thai_ci; +extern CHARSET_INFO my_charset_tis620_bin; +extern CHARSET_INFO my_charset_ucs2_general_ci; +extern CHARSET_INFO my_charset_ucs2_bin; +extern CHARSET_INFO my_charset_ucs2_unicode_ci; +extern CHARSET_INFO my_charset_ujis_japanese_ci; +extern CHARSET_INFO my_charset_ujis_bin; +extern CHARSET_INFO my_charset_utf8_general_ci; +extern CHARSET_INFO my_charset_utf8_unicode_ci; +extern CHARSET_INFO my_charset_utf8_bin; +extern CHARSET_INFO my_charset_cp1250_czech_ci; +extern CHARSET_INFO my_charset_filename; +extern size_t my_strnxfrm_simple(CHARSET_INFO *, uchar *, size_t, + const uchar *, size_t); +size_t my_strnxfrmlen_simple(CHARSET_INFO *, size_t); +extern int my_strnncoll_simple(CHARSET_INFO *, const uchar *, size_t, + const uchar *, size_t, my_bool); +extern int my_strnncollsp_simple(CHARSET_INFO *, const uchar *, size_t, + const uchar *, size_t, + my_bool diff_if_only_endspace_difference); +extern void my_hash_sort_simple(CHARSET_INFO *cs, + const uchar *key, size_t len, + ulong *nr1, ulong *nr2); +extern size_t my_lengthsp_8bit(CHARSET_INFO *cs, const char *ptr, size_t length); +extern uint my_instr_simple(struct charset_info_st *, + const char *b, size_t b_length, + const char *s, size_t s_length, + my_match_t *match, uint nmatch); +extern size_t my_caseup_str_8bit(CHARSET_INFO *, char *); +extern size_t my_casedn_str_8bit(CHARSET_INFO *, char *); +extern size_t my_caseup_8bit(CHARSET_INFO *, char *src, size_t srclen, + char *dst, size_t dstlen); +extern size_t my_casedn_8bit(CHARSET_INFO *, char *src, size_t srclen, + char *dst, size_t dstlen); +extern int my_strcasecmp_8bit(CHARSET_INFO * cs, const char *, const char *); +int my_mb_wc_8bit(CHARSET_INFO *cs,ulong *wc, const uchar *s,const uchar *e); +int my_wc_mb_8bit(CHARSET_INFO *cs,ulong wc, uchar *s, uchar *e); +int my_mb_ctype_8bit(CHARSET_INFO *,int *, const uchar *,const uchar *); +int my_mb_ctype_mb(CHARSET_INFO *,int *, const uchar *,const uchar *); +size_t my_scan_8bit(CHARSET_INFO *cs, const char *b, const char *e, int sq); +size_t my_snprintf_8bit(struct charset_info_st *, char *to, size_t n, + const char *fmt, ...) + __attribute__((format(printf, 4, 5))); +long my_strntol_8bit(CHARSET_INFO *, const char *s, size_t l, int base, + char **e, int *err); +ulong my_strntoul_8bit(CHARSET_INFO *, const char *s, size_t l, int base, + char **e, int *err); +longlong my_strntoll_8bit(CHARSET_INFO *, const char *s, size_t l, int base, + char **e, int *err); +ulonglong my_strntoull_8bit(CHARSET_INFO *, const char *s, size_t l, int base, + char **e, int *err); +double my_strntod_8bit(CHARSET_INFO *, char *s, size_t l,char **e, + int *err); +size_t my_long10_to_str_8bit(CHARSET_INFO *, char *to, size_t l, int radix, + long int val); +size_t my_longlong10_to_str_8bit(CHARSET_INFO *, char *to, size_t l, int radix, + longlong val); +longlong my_strtoll10_8bit(CHARSET_INFO *cs, + const char *nptr, char **endptr, int *error); +longlong my_strtoll10_ucs2(CHARSET_INFO *cs, + const char *nptr, char **endptr, int *error); +ulonglong my_strntoull10rnd_8bit(CHARSET_INFO *cs, + const char *str, size_t length, int + unsigned_fl, char **endptr, int *error); +ulonglong my_strntoull10rnd_ucs2(CHARSET_INFO *cs, + const char *str, size_t length, + int unsigned_fl, char **endptr, int *error); +void my_fill_8bit(CHARSET_INFO *cs, char* to, size_t l, int fill); +my_bool my_like_range_simple(CHARSET_INFO *cs, + const char *ptr, size_t ptr_length, + pbool escape, pbool w_one, pbool w_many, + size_t res_length, + char *min_str, char *max_str, + size_t *min_length, size_t *max_length); +my_bool my_like_range_mb(CHARSET_INFO *cs, + const char *ptr, size_t ptr_length, + pbool escape, pbool w_one, pbool w_many, + size_t res_length, + char *min_str, char *max_str, + size_t *min_length, size_t *max_length); +my_bool my_like_range_ucs2(CHARSET_INFO *cs, + const char *ptr, size_t ptr_length, + pbool escape, pbool w_one, pbool w_many, + size_t res_length, + char *min_str, char *max_str, + size_t *min_length, size_t *max_length); +int my_wildcmp_8bit(CHARSET_INFO *, + const char *str,const char *str_end, + const char *wildstr,const char *wildend, + int escape, int w_one, int w_many); +int my_wildcmp_bin(CHARSET_INFO *, + const char *str,const char *str_end, + const char *wildstr,const char *wildend, + int escape, int w_one, int w_many); +size_t my_numchars_8bit(CHARSET_INFO *, const char *b, const char *e); +size_t my_numcells_8bit(CHARSET_INFO *, const char *b, const char *e); +size_t my_charpos_8bit(CHARSET_INFO *, const char *b, const char *e, size_t pos); +size_t my_well_formed_len_8bit(CHARSET_INFO *, const char *b, const char *e, + size_t pos, int *error); +uint my_mbcharlen_8bit(CHARSET_INFO *, uint c); +extern size_t my_caseup_str_mb(CHARSET_INFO *, char *); +extern size_t my_casedn_str_mb(CHARSET_INFO *, char *); +extern size_t my_caseup_mb(CHARSET_INFO *, char *src, size_t srclen, + char *dst, size_t dstlen); +extern size_t my_casedn_mb(CHARSET_INFO *, char *src, size_t srclen, + char *dst, size_t dstlen); +extern int my_strcasecmp_mb(CHARSET_INFO * cs,const char *, const char *); +int my_wildcmp_mb(CHARSET_INFO *, + const char *str,const char *str_end, + const char *wildstr,const char *wildend, + int escape, int w_one, int w_many); +size_t my_numchars_mb(CHARSET_INFO *, const char *b, const char *e); +size_t my_numcells_mb(CHARSET_INFO *, const char *b, const char *e); +size_t my_charpos_mb(CHARSET_INFO *, const char *b, const char *e, size_t pos); +size_t my_well_formed_len_mb(CHARSET_INFO *, const char *b, const char *e, + size_t pos, int *error); +uint my_instr_mb(struct charset_info_st *, + const char *b, size_t b_length, + const char *s, size_t s_length, + my_match_t *match, uint nmatch); +int my_wildcmp_unicode(CHARSET_INFO *cs, + const char *str, const char *str_end, + const char *wildstr, const char *wildend, + int escape, int w_one, int w_many, + MY_UNICASE_INFO **weights); +extern my_bool my_parse_charset_xml(const char *bug, size_t len, + int (*add)(CHARSET_INFO *cs)); +extern char *my_strchr(CHARSET_INFO *cs, const char *str, const char *end, + pchar c); +my_bool my_propagate_simple(CHARSET_INFO *cs, const uchar *str, size_t len); +my_bool my_propagate_complex(CHARSET_INFO *cs, const uchar *str, size_t len); +uint my_string_repertoire(CHARSET_INFO *cs, const char *str, ulong len); +my_bool my_charset_is_ascii_based(CHARSET_INFO *cs); +my_bool my_charset_is_8bit_pure_ascii(CHARSET_INFO *cs); +#include <stdarg.h> +#include <typelib.h> +#include "my_alloc.h" +typedef struct st_used_mem +{ + struct st_used_mem *next; + unsigned int left; + unsigned int size; +} USED_MEM; +typedef struct st_mem_root +{ + USED_MEM *free; + USED_MEM *used; + USED_MEM *pre_alloc; + size_t min_malloc; + size_t block_size; + unsigned int block_num; + unsigned int first_block_usage; + void (*error_handler)(void); +} MEM_ROOT; +typedef struct st_typelib { + unsigned int count; + const char *name; + const char **type_names; + unsigned int *type_lengths; +} TYPELIB; +extern my_ulonglong find_typeset(char *x, TYPELIB *typelib,int *error_position); +extern int find_type_or_exit(const char *x, TYPELIB *typelib, + const char *option); +extern int find_type(char *x, const 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 *copy_typelib(MEM_ROOT *root, TYPELIB *from); +extern TYPELIB sql_protocol_typelib; +extern void *my_malloc(size_t Size,myf MyFlags); +extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags); +extern void my_no_flags_free(void *ptr); +extern void *my_memdup(const void *from,size_t length,myf MyFlags); +extern char *my_strdup(const char *from,myf MyFlags); +extern char *my_strndup(const char *from, size_t length, + myf MyFlags); +extern uint my_get_large_page_size(void); +extern uchar * my_large_malloc(size_t size, myf my_flags); +extern void my_large_free(uchar * ptr, myf my_flags); +extern int errno; +extern char errbuff[(2)][(256)]; +extern char *home_dir; +extern const char *my_progname; +extern char curr_dir[]; +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; +extern ulong my_thread_stack_size; +extern my_bool my_use_large_pages; +extern uint my_large_page_size; +extern CHARSET_INFO *default_charset_info; +extern CHARSET_INFO *all_charsets[256]; +extern CHARSET_INFO compiled_charsets[]; +extern ulong my_file_opened,my_stream_opened, my_tmp_file_created; +extern ulong my_file_total_opened; +extern uint mysys_usage_id; +extern my_bool my_init_done; +extern void (*my_sigtstp_cleanup)(void), + (*my_sigtstp_restart)(void), + (*my_abort_hook)(int); +extern int my_umask, + my_umask_dir, + my_recived_signals, + my_safe_to_handle_signal, + my_dont_interrupt; +extern my_bool 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 my_disable_locking, my_disable_async_io, + my_disable_flush_key_blocks, my_disable_symlinks; +extern char wild_many,wild_one,wild_prefix; +extern const char *charsets_dir; +extern char *my_defaults_extra_file; +extern const char *my_defaults_group_suffix; +extern const char *my_defaults_file; +extern my_bool timed_mutexes; +typedef struct wild_file_pack +{ + uint wilds; + uint not_pos; + char * *wild; +} WF_PACK; +enum loglevel { + ERROR_LEVEL, + WARNING_LEVEL, + INFORMATION_LEVEL +}; +enum cache_type +{ + TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE, + SEQ_READ_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 +{ + File file; + int rc_seek,error,inited; + uint rc_length,read_length,reclength; + my_off_t rc_record_pos,end_of_file; + uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos; + 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 +{ + char * name; + enum file_type type; +}; +extern struct st_my_file_info *my_file_info; +typedef struct st_dynamic_array +{ + uchar *buffer; + uint elements,max_element; + uint alloc_increment; + uint size_of_element; +} DYNAMIC_ARRAY; +typedef struct st_my_tmpdir +{ + DYNAMIC_ARRAY full_list; + char **list; + uint cur, max; + pthread_mutex_t mutex; +} MY_TMPDIR; +typedef struct st_dynamic_string +{ + char *str; + size_t length,max_length,alloc_increment; +} DYNAMIC_STRING; +struct st_io_cache; +typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*); +typedef struct st_io_cache_share +{ + pthread_mutex_t mutex; + pthread_cond_t cond; + pthread_cond_t cond_writer; + my_off_t pos_in_file; + struct st_io_cache *source_cache; + uchar *buffer; + uchar *read_end; + int running_threads; + int total_threads; + int error; +} IO_CACHE_SHARE; +typedef struct st_io_cache +{ + my_off_t pos_in_file; + my_off_t end_of_file; + uchar *read_pos; + uchar *read_end; + uchar *buffer; + uchar *request_pos; + uchar *write_buffer; + uchar *append_read_pos; + uchar *write_pos; + uchar *write_end; + uchar **current_pos, **current_end; + pthread_mutex_t append_buffer_lock; + IO_CACHE_SHARE *share; + int (*read_function)(struct st_io_cache *,uchar *,size_t); + int (*write_function)(struct st_io_cache *,const uchar *,size_t); + enum cache_type type; + IO_CACHE_CALLBACK pre_read; + IO_CACHE_CALLBACK post_read; + IO_CACHE_CALLBACK pre_close; + ulong disk_writes; + void* arg; + char *file_name; + char *dir,*prefix; + File file; + int seek_not_done,error; + size_t buffer_length; + size_t read_length; + myf myflags; + my_bool alloced_buffer; +} IO_CACHE; +typedef int (*qsort2_cmp)(const void *, const void *, const void *); +int my_b_copy_to_file(IO_CACHE *cache, FILE *file); +my_off_t my_b_append_tell(IO_CACHE* info); +my_off_t my_b_safe_tell(IO_CACHE* info); +typedef uint32 ha_checksum; +typedef int (*Process_option_func)(void *ctx, const char *group_name, + const char *option); +#include <my_alloc.h> +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(char * buf,size_t 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 void *my_once_alloc(size_t Size,myf MyFlags); +extern void my_once_free(void); +extern char *my_once_strdup(const char *src,myf myflags); +extern void *my_once_memdup(const void *src, size_t 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 AccessFlags, 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 size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags); +extern size_t my_pread(File Filedes,uchar *Buffer,size_t 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 size_t my_write(File Filedes,const uchar *Buffer,size_t Count, + myf MyFlags); +extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count, + my_off_t offset,myf MyFlags); +extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags); +extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t 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 void *_mymalloc(size_t uSize,const char *sFile, + uint uLine, myf MyFlag); +extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile, + uint uLine, myf MyFlag); +extern void * my_multi_malloc (myf MyFlags, ...); +extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag); +extern int _sanity(const char *sFile, uint uLine); +extern void *_my_memdup(const void *from, size_t length, + const char *sFile, uint uLine,myf MyFlag); +extern char * _my_strdup(const char *from, const char *sFile, uint uLine, + myf MyFlag); +extern char *_my_strndup(const char *from, size_t length, + const char *sFile, uint uLine, + myf MyFlag); +extern void *my_memmem(const void *haystack, size_t haystacklen, + const void *needle, size_t needlelen); +extern int check_if_legal_filename(const char *path); +extern int check_if_legal_tablename(const char *path); +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_sync_dir(const char *dir_name, myf my_flags); +extern int my_sync_dir_by_file(const char *file_name, myf my_flags); +extern int my_error (int nr,myf MyFlags, ...); +extern int my_printf_error (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 char * my_filename(File fd); +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,void (*func)(int)); +extern size_t dirname_part(char * to,const char *name, size_t *to_res_length); +extern size_t dirname_length(const char *name); +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(char * name); +extern char * fn_ext(const char *name); +extern char * fn_same(char * toname,const char *name,int flag); +extern char * fn_format(char * to,const char *name,const char *dir, + const char *form, uint flag); +extern size_t strlength(const char *str); +extern void pack_dirname(char * to,const char *from); +extern size_t unpack_dirname(char * to,const char *from); +extern size_t cleanup_dirname(char * to,const char *from); +extern size_t system_filename(char * to,const char *from); +extern size_t unpack_filename(char * to,const char *from); +extern char * intern_filename(char * to,const char *from); +extern char * directory_file_name(char * dst, const char *src); +extern int pack_filename(char * to, const char *name, size_t max_length); +extern char * my_path(char * to,const char *progname, + const char *own_pathname_part); +extern char * my_load_path(char * 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(char * 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_t strip_sp(char * str); +extern my_bool array_append_string_unique(const char *str, + const char **array, size_t size); +extern void get_date(char * to,int timeflag,time_t use_time); +extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr, + pbool remove_garbage); +extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file, + size_t reclength,enum cache_type type, + pbool use_async_io); +extern int read_cache_record(RECORD_CACHE *info,uchar *to); +extern int end_record_cache(RECORD_CACHE *info); +extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos, + const uchar *record,size_t length); +extern int flush_write_cache(RECORD_CACHE *info); +extern long my_clock(void); +extern void sigtstp_handler(int signal_number); +extern void handle_recived_signals(void); +extern void my_set_alarm_variable(int signo); +extern void my_string_ptr_sort(uchar *base,uint items,size_t size); +extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements, + size_t size_of_element,uchar *buffer[]); +extern void my_qsort(void *base_ptr, size_t total_elems, size_t size, + qsort_cmp cmp); +extern void my_qsort2(void *base_ptr, size_t total_elems, size_t size, + qsort2_cmp cmp, void *cmp_argument); +extern qsort2_cmp get_ptr_compare(size_t); +void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos); +my_off_t my_get_ptr(uchar *ptr, size_t pack_length); +extern int init_io_cache(IO_CACHE *info,File file,size_t 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,uchar *Buffer,size_t Count); +extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count); +extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare, + IO_CACHE *write_cache, uint num_threads); +extern void remove_io_thread(IO_CACHE *info); +extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count); +extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count); +extern int _my_b_get(IO_CACHE *info); +extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count); +extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count); +extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count); +extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count); +extern int my_block_write(IO_CACHE *info, const uchar *Buffer, + size_t Count, my_off_t pos); +extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock); +extern int end_io_cache(IO_CACHE *info); +extern size_t my_b_fill(IO_CACHE *info); +extern void my_b_seek(IO_CACHE *info,my_off_t pos); +extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length); +extern my_off_t my_b_filelength(IO_CACHE *info); +extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...); +extern size_t 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, size_t 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); +extern my_bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size, + void *init_buffer, uint init_alloc, + uint alloc_increment + ); +extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size, + uint init_alloc,uint alloc_increment + ); +extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element); +extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array); +extern uchar *pop_dynamic(DYNAMIC_ARRAY*); +extern my_bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index); +extern my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements); +extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * 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); +extern int get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element); +extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str, + size_t init_alloc,size_t alloc_increment); +extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append); +my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append, + size_t length); +extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append, + ...); +extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str); +extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size); +extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n); +extern void dynstr_free(DYNAMIC_STRING *str); +extern void init_alloc_root(MEM_ROOT *mem_root, size_t block_size, + size_t pre_alloc_size); +extern void *alloc_root(MEM_ROOT *mem_root, size_t Size); +extern void *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, size_t block_size, + size_t prealloc_size); +extern char *strdup_root(MEM_ROOT *root,const char *str); +extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len); +extern void *memdup_root(MEM_ROOT *root,const void *str, size_t 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(uchar *, size_t *, size_t *); +extern my_bool my_uncompress(uchar *, size_t , size_t *); +extern uchar *my_compress_alloc(const uchar *packet, size_t *len, + size_t *complen); +extern int packfrm(uchar *, size_t, uchar **, size_t *); +extern int unpackfrm(uchar **, size_t *, const uchar *); +extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem, + size_t count); +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); +extern time_t my_time(myf flags); +extern ulonglong my_getsystime(void); +extern ulonglong my_micro_time(); +extern ulonglong my_micro_time_and_time(time_t *time_arg); +time_t my_time_possible_from_micro(ulonglong microtime); +extern my_bool my_gethwaddr(uchar *to); +extern int my_getncpus(); +#include <sys/mman.h> +int my_msync(int, void *, size_t, int); +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 my_bool resolve_charset(const char *cs_name, + CHARSET_INFO *default_cs, + CHARSET_INFO **cs); +extern my_bool resolve_collation(const char *cl_name, + CHARSET_INFO *default_cl, + CHARSET_INFO **cl); +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 size_t escape_string_for_mysql(CHARSET_INFO *charset_info, + char *to, size_t to_length, + const char *from, size_t length); +extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info, + char *to, size_t to_length, + const char *from, size_t 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); +#include <my_time.h> +#include "my_global.h" +#include "mysql_time.h" +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 +}; +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; +extern ulonglong log_10_int[20]; +extern uchar days_in_month[]; +typedef long my_time_t; +my_bool check_date(const MYSQL_TIME *ltime, my_bool not_zero_date, + ulong flags, int *was_cut); +enum enum_mysql_timestamp_type +str_to_datetime(const char *str, uint length, MYSQL_TIME *l_time, + uint flags, int *was_cut); +longlong number_to_datetime(longlong nr, MYSQL_TIME *time_res, + uint flags, int *was_cut); +ulonglong TIME_to_ulonglong_datetime(const MYSQL_TIME *); +ulonglong TIME_to_ulonglong_date(const MYSQL_TIME *); +ulonglong TIME_to_ulonglong_time(const MYSQL_TIME *); +ulonglong TIME_to_ulonglong(const MYSQL_TIME *); +my_bool str_to_time(const char *str,uint length, MYSQL_TIME *l_time, + int *warning); +int check_time_range(struct st_mysql_time *, int *warning); +long calc_daynr(uint year,uint month,uint day); +uint calc_days_in_year(uint year); +uint year_2000_handling(uint year); +void my_init_time(void); +static inline my_bool validate_timestamp_range(const MYSQL_TIME *t) +{ + if ((t->year > 2038 || t->year < (1900 + 70 - 1)) || + (t->year == 2038 && (t->month > 1 || t->day > 19)) || + (t->year == (1900 + 70 - 1) && (t->month < 12 || t->day < 31))) + return (0); + return (1); +} +my_time_t +my_system_gmt_sec(const MYSQL_TIME *t, long *my_timezone, + my_bool *in_dst_time_gap); +void set_zero_time(MYSQL_TIME *tm, enum enum_mysql_timestamp_type time_type); +int my_time_to_str(const MYSQL_TIME *l_time, char *to); +int my_date_to_str(const MYSQL_TIME *l_time, char *to); +int my_datetime_to_str(const MYSQL_TIME *l_time, char *to); +int my_TIME_to_str(const MYSQL_TIME *l_time, char *to); +enum interval_type +{ + INTERVAL_YEAR, INTERVAL_QUARTER, INTERVAL_MONTH, INTERVAL_WEEK, INTERVAL_DAY, + INTERVAL_HOUR, INTERVAL_MINUTE, INTERVAL_SECOND, INTERVAL_MICROSECOND, + INTERVAL_YEAR_MONTH, INTERVAL_DAY_HOUR, INTERVAL_DAY_MINUTE, + INTERVAL_DAY_SECOND, INTERVAL_HOUR_MINUTE, INTERVAL_HOUR_SECOND, + INTERVAL_MINUTE_SECOND, INTERVAL_DAY_MICROSECOND, INTERVAL_HOUR_MICROSECOND, + INTERVAL_MINUTE_MICROSECOND, INTERVAL_SECOND_MICROSECOND, INTERVAL_LAST +}; +#include <m_string.h> +#include <strings.h> +#include <string.h> +#include <stdarg.h> +#include <strings.h> +#include <memory.h> +extern void *(*my_str_malloc)(size_t); +extern void (*my_str_free)(void *); +extern char *stpcpy(char *, const char *); +extern char _dig_vec_upper[]; +extern char _dig_vec_lower[]; +extern const double log_10[309]; +extern void bmove512(uchar *dst,const uchar *src,size_t len); +extern void bmove_upp(uchar *dst,const uchar *src,size_t len); +extern void bchange(uchar *dst,size_t old_len,const uchar *src, + size_t new_len,size_t tot_len); +extern void strappend(char *s,size_t len,pchar fill); +extern char *strend(const char *s); +extern char *strcend(const char *, pchar); +extern char *strfield(char *src,int fields,int chars,int blanks, + int tabch); +extern char *strfill(char * s,size_t len,pchar fill); +extern size_t strinstr(const char *str,const char *search); +extern size_t r_strinstr(const char *str, size_t from, const char *search); +extern char *strkey(char *dst,char *head,char *tail,char *flags); +extern char *strmake(char *dst,const char *src,size_t length); +extern char *strnmov(char *dst,const char *src,size_t n); +extern char *strsuff(const char *src,const char *suffix); +extern char *strcont(const char *src,const char *set); +extern char *strxcat (char *dst,const char *src, ...); +extern char *strxmov (char *dst,const char *src, ...); +extern char *strxcpy (char *dst,const char *src, ...); +extern char *strxncat (char *dst,size_t len, const char *src, ...); +extern char *strxnmov (char *dst,size_t len, const char *src, ...); +extern char *strxncpy (char *dst,size_t len, const char *src, ...); +extern int is_prefix(const char *, const char *); +double my_strtod(const char *str, char **end, int *error); +double my_atof(const char *nptr); +extern char *llstr(longlong value,char *buff); +extern char *ullstr(longlong value,char *buff); +extern char *int2str(long val, char *dst, int radix, int upcase); +extern char *int10_to_str(long val,char *dst,int radix); +extern char *str2int(const char *src,int radix,long lower,long upper, + long *val); +longlong my_strtoll10(const char *nptr, char **endptr, int *error); +extern char *longlong2str(longlong val,char *dst,int radix); +extern char *longlong10_to_str(longlong val,char *dst,int radix); +extern size_t my_vsnprintf(char *str, size_t n, + const char *format, va_list ap); +extern size_t my_snprintf(char *to, size_t n, const char *fmt, ...) + __attribute__((format(printf, 3, 4))); +struct st_mysql_lex_string +{ + char *str; + size_t length; +}; +typedef struct st_mysql_lex_string LEX_STRING; +#include <hash.h> +typedef uchar *(*hash_get_key)(const uchar *,size_t*,my_bool); +typedef void (*hash_free_key)(void *); +typedef struct st_hash { + size_t key_offset,key_length; + size_t blength; + ulong records; + uint flags; + DYNAMIC_ARRAY array; + hash_get_key get_key; + void (*free)(void *); + CHARSET_INFO *charset; +} HASH; +typedef uint HASH_SEARCH_STATE; +my_bool _hash_init(HASH *hash, uint growth_size,CHARSET_INFO *charset, + ulong default_array_elements, size_t key_offset, + size_t key_length, hash_get_key get_key, + void (*free_element)(void*), uint flags ); +void hash_free(HASH *tree); +void my_hash_reset(HASH *hash); +uchar *hash_element(HASH *hash,ulong idx); +uchar *hash_search(const HASH *info, const uchar *key, size_t length); +uchar *hash_first(const HASH *info, const uchar *key, size_t length, + HASH_SEARCH_STATE *state); +uchar *hash_next(const HASH *info, const uchar *key, size_t length, + HASH_SEARCH_STATE *state); +my_bool my_hash_insert(HASH *info,const uchar *data); +my_bool hash_delete(HASH *hash,uchar *record); +my_bool hash_update(HASH *hash,uchar *record,uchar *old_key,size_t old_key_length); +void hash_replace(HASH *hash, HASH_SEARCH_STATE *state, uchar *new_row); +my_bool hash_check(HASH *hash); +#include <signal.h> +#include <thr_lock.h> +#include <my_pthread.h> +#include <my_list.h> +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,unsigned char * argument); +struct st_thr_lock; +extern ulong locks_immediate,locks_waited ; +enum thr_lock_type { TL_IGNORE=-1, + TL_UNLOCK, + TL_READ, + TL_READ_WITH_SHARED_LOCKS, + TL_READ_HIGH_PRIORITY, + TL_READ_NO_INSERT, + TL_WRITE_ALLOW_WRITE, + TL_WRITE_ALLOW_READ, + TL_WRITE_CONCURRENT_INSERT, + TL_WRITE_DELAYED, + TL_WRITE_DEFAULT, + TL_WRITE_LOW_PRIORITY, + TL_WRITE, + TL_WRITE_ONLY}; +enum enum_thr_lock_result { THR_LOCK_SUCCESS= 0, THR_LOCK_ABORTED= 1, + THR_LOCK_WAIT_TIMEOUT= 2, THR_LOCK_DEADLOCK= 3 }; +extern ulong max_write_lock_count; +extern ulong table_lock_wait_timeout; +extern my_bool thr_lock_inited; +extern enum thr_lock_type thr_upgraded_concurrent_insert_lock; +typedef struct st_thr_lock_info +{ + pthread_t thread; + my_thread_id thread_id; + ulong n_cursors; +} THR_LOCK_INFO; +typedef struct st_thr_lock_owner +{ + THR_LOCK_INFO *info; +} THR_LOCK_OWNER; +typedef struct st_thr_lock_data { + THR_LOCK_OWNER *owner; + struct st_thr_lock_data *next,**prev; + struct st_thr_lock *lock; + pthread_cond_t *cond; + enum thr_lock_type type; + void *status_param; + void *debug_print_param; +} THR_LOCK_DATA; +struct st_lock_list { + THR_LOCK_DATA *data,**last; +}; +typedef struct st_thr_lock { + LIST list; + pthread_mutex_t mutex; + struct st_lock_list read_wait; + struct st_lock_list read; + struct st_lock_list write_wait; + struct st_lock_list write; + ulong write_lock_count; + uint read_no_write_count; + void (*get_status)(void*, int); + void (*copy_status)(void*,void*); + void (*update_status)(void*); + void (*restore_status)(void*); + my_bool (*check_status)(void *); +} THR_LOCK; +extern LIST *thr_lock_thread_list; +extern pthread_mutex_t THR_LOCK_lock; +my_bool init_thr_lock(void); +void thr_lock_info_init(THR_LOCK_INFO *info); +void thr_lock_init(THR_LOCK *lock); +void thr_lock_delete(THR_LOCK *lock); +void thr_lock_data_init(THR_LOCK *lock,THR_LOCK_DATA *data, + void *status_param); +enum enum_thr_lock_result thr_lock(THR_LOCK_DATA *data, + THR_LOCK_OWNER *owner, + enum thr_lock_type lock_type); +void thr_unlock(THR_LOCK_DATA *data); +enum enum_thr_lock_result thr_multi_lock(THR_LOCK_DATA **data, + uint count, THR_LOCK_OWNER *owner); +void thr_multi_unlock(THR_LOCK_DATA **data,uint count); +void thr_abort_locks(THR_LOCK *lock, my_bool upgrade_lock); +my_bool thr_abort_locks_for_thread(THR_LOCK *lock, my_thread_id thread); +void thr_print_locks(void); +my_bool thr_upgrade_write_delay_lock(THR_LOCK_DATA *data); +void thr_downgrade_write_lock(THR_LOCK_DATA *data, + enum thr_lock_type new_lock_type); +my_bool thr_reschedule_write_lock(THR_LOCK_DATA *data); +#include <my_base.h> +#include <my_global.h> +#include <my_dir.h> +#include <sys/stat.h> +typedef struct fileinfo +{ + char *name; + struct stat *mystat; +} FILEINFO; +typedef struct st_my_dir +{ + struct fileinfo *dir_entry; + uint number_off_files; +} MY_DIR; +extern MY_DIR *my_dir(const char *path,myf MyFlags); +extern void my_dirend(MY_DIR *buffer); +extern struct stat *my_stat(const char *path, struct stat *stat_area, myf my_flags); +extern int my_fstat(int filenr, struct stat *stat_area, myf MyFlags); +#include <my_sys.h> +#include <m_string.h> +#include <errno.h> +#include <my_list.h> +enum ha_rkey_function { + HA_READ_KEY_EXACT, + HA_READ_KEY_OR_NEXT, + HA_READ_KEY_OR_PREV, + HA_READ_AFTER_KEY, + HA_READ_BEFORE_KEY, + HA_READ_PREFIX, + HA_READ_PREFIX_LAST, + HA_READ_PREFIX_LAST_OR_PREV, + HA_READ_MBR_CONTAIN, + HA_READ_MBR_INTERSECT, + HA_READ_MBR_WITHIN, + HA_READ_MBR_DISJOINT, + HA_READ_MBR_EQUAL +}; +enum ha_key_alg { + HA_KEY_ALG_UNDEF= 0, + HA_KEY_ALG_BTREE= 1, + HA_KEY_ALG_RTREE= 2, + HA_KEY_ALG_HASH= 3, + HA_KEY_ALG_FULLTEXT= 4 +}; +enum ha_storage_media { + HA_SM_DEFAULT= 0, + HA_SM_DISK= 1, + HA_SM_MEMORY= 2 +}; +enum ha_extra_function { + HA_EXTRA_NORMAL=0, + HA_EXTRA_QUICK=1, + HA_EXTRA_NOT_USED=2, + HA_EXTRA_CACHE=3, + HA_EXTRA_NO_CACHE=4, + HA_EXTRA_NO_READCHECK=5, + HA_EXTRA_READCHECK=6, + HA_EXTRA_KEYREAD=7, + HA_EXTRA_NO_KEYREAD=8, + HA_EXTRA_NO_USER_CHANGE=9, + HA_EXTRA_KEY_CACHE=10, + HA_EXTRA_NO_KEY_CACHE=11, + HA_EXTRA_WAIT_LOCK=12, + HA_EXTRA_NO_WAIT_LOCK=13, + HA_EXTRA_WRITE_CACHE=14, + HA_EXTRA_FLUSH_CACHE=15, + HA_EXTRA_NO_KEYS=16, + HA_EXTRA_KEYREAD_CHANGE_POS=17, + HA_EXTRA_REMEMBER_POS=18, + HA_EXTRA_RESTORE_POS=19, + HA_EXTRA_REINIT_CACHE=20, + HA_EXTRA_FORCE_REOPEN=21, + HA_EXTRA_FLUSH, + HA_EXTRA_NO_ROWS, + HA_EXTRA_RESET_STATE, + HA_EXTRA_IGNORE_DUP_KEY, + HA_EXTRA_NO_IGNORE_DUP_KEY, + HA_EXTRA_PREPARE_FOR_DROP, + HA_EXTRA_PREPARE_FOR_UPDATE, + HA_EXTRA_PRELOAD_BUFFER_SIZE, + HA_EXTRA_CHANGE_KEY_TO_UNIQUE, + HA_EXTRA_CHANGE_KEY_TO_DUP, + HA_EXTRA_KEYREAD_PRESERVE_FIELDS, + HA_EXTRA_MMAP, + HA_EXTRA_IGNORE_NO_KEY, + HA_EXTRA_NO_IGNORE_NO_KEY, + HA_EXTRA_MARK_AS_LOG_TABLE, + HA_EXTRA_WRITE_CAN_REPLACE, + HA_EXTRA_WRITE_CANNOT_REPLACE, + HA_EXTRA_DELETE_CANNOT_BATCH, + HA_EXTRA_UPDATE_CANNOT_BATCH, + HA_EXTRA_INSERT_WITH_UPDATE, + HA_EXTRA_PREPARE_FOR_RENAME, + HA_EXTRA_ATTACH_CHILDREN, + HA_EXTRA_DETACH_CHILDREN +}; +enum ha_panic_function { + HA_PANIC_CLOSE, + HA_PANIC_WRITE, + HA_PANIC_READ +}; +enum ha_base_keytype { + HA_KEYTYPE_END=0, + HA_KEYTYPE_TEXT=1, + HA_KEYTYPE_BINARY=2, + HA_KEYTYPE_SHORT_INT=3, + HA_KEYTYPE_LONG_INT=4, + HA_KEYTYPE_FLOAT=5, + HA_KEYTYPE_DOUBLE=6, + HA_KEYTYPE_NUM=7, + HA_KEYTYPE_USHORT_INT=8, + HA_KEYTYPE_ULONG_INT=9, + HA_KEYTYPE_LONGLONG=10, + HA_KEYTYPE_ULONGLONG=11, + HA_KEYTYPE_INT24=12, + HA_KEYTYPE_UINT24=13, + HA_KEYTYPE_INT8=14, + HA_KEYTYPE_VARTEXT1=15, + HA_KEYTYPE_VARBINARY1=16, + HA_KEYTYPE_VARTEXT2=17, + HA_KEYTYPE_VARBINARY2=18, + HA_KEYTYPE_BIT=19 +}; +typedef ulong key_part_map; +enum en_fieldtype { + FIELD_LAST=-1,FIELD_NORMAL,FIELD_SKIP_ENDSPACE,FIELD_SKIP_PRESPACE, + FIELD_SKIP_ZERO,FIELD_BLOB,FIELD_CONSTANT,FIELD_INTERVALL,FIELD_ZERO, + FIELD_VARCHAR,FIELD_CHECK, + FIELD_enum_val_count +}; +enum data_file_type { + STATIC_RECORD, DYNAMIC_RECORD, COMPRESSED_RECORD, BLOCK_RECORD +}; +typedef struct st_key_range +{ + const uchar *key; + uint length; + key_part_map keypart_map; + enum ha_rkey_function flag; +} key_range; +typedef struct st_key_multi_range +{ + key_range start_key; + key_range end_key; + char *ptr; + uint range_flag; +} KEY_MULTI_RANGE; +typedef my_off_t ha_rows; +typedef void (* invalidator_by_filename)(const char * filename); +#include <queues.h> +typedef struct st_queue { + uchar **root; + void *first_cmp_arg; + uint elements; + uint max_elements; + uint offset_to_key; + int max_at_top; + int (*compare)(void *, uchar *,uchar *); + uint auto_extent; +} QUEUE; +typedef int (*queue_compare)(void *,uchar *, uchar *); +int init_queue(QUEUE *queue,uint max_elements,uint offset_to_key, + pbool max_at_top, queue_compare compare, + void *first_cmp_arg); +int init_queue_ex(QUEUE *queue,uint max_elements,uint offset_to_key, + pbool max_at_top, queue_compare compare, + void *first_cmp_arg, uint auto_extent); +int reinit_queue(QUEUE *queue,uint max_elements,uint offset_to_key, + pbool max_at_top, queue_compare compare, + void *first_cmp_arg); +int resize_queue(QUEUE *queue, uint max_elements); +void delete_queue(QUEUE *queue); +void queue_insert(QUEUE *queue,uchar *element); +int queue_insert_safe(QUEUE *queue, uchar *element); +uchar *queue_remove(QUEUE *queue,uint idx); +void _downheap(QUEUE *queue,uint idx); +void queue_fix(QUEUE *queue); +#include "sql_bitmap.h" +#include <my_bitmap.h> +#include <m_string.h> +typedef uint32 my_bitmap_map; +typedef struct st_bitmap +{ + my_bitmap_map *bitmap; + uint n_bits; + my_bitmap_map last_word_mask; + my_bitmap_map *last_word_ptr; + pthread_mutex_t *mutex; +} MY_BITMAP; +extern void create_last_word_mask(MY_BITMAP *map); +extern my_bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits, + my_bool thread_safe); +extern my_bool bitmap_is_clear_all(const MY_BITMAP *map); +extern my_bool bitmap_is_prefix(const MY_BITMAP *map, uint prefix_size); +extern my_bool bitmap_is_set_all(const MY_BITMAP *map); +extern my_bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2); +extern my_bool bitmap_is_overlapping(const MY_BITMAP *map1, + const MY_BITMAP *map2); +extern my_bool bitmap_test_and_set(MY_BITMAP *map, uint bitmap_bit); +extern my_bool bitmap_test_and_clear(MY_BITMAP *map, uint bitmap_bit); +extern my_bool bitmap_fast_test_and_set(MY_BITMAP *map, uint bitmap_bit); +extern uint bitmap_set_next(MY_BITMAP *map); +extern uint bitmap_get_first(const MY_BITMAP *map); +extern uint bitmap_get_first_set(const MY_BITMAP *map); +extern uint bitmap_bits_set(const MY_BITMAP *map); +extern void bitmap_free(MY_BITMAP *map); +extern void bitmap_set_above(MY_BITMAP *map, uint from_byte, uint use_bit); +extern void bitmap_set_prefix(MY_BITMAP *map, uint prefix_size); +extern void bitmap_intersect(MY_BITMAP *map, const MY_BITMAP *map2); +extern void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2); +extern void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2); +extern void bitmap_xor(MY_BITMAP *map, const MY_BITMAP *map2); +extern void bitmap_invert(MY_BITMAP *map); +extern void bitmap_copy(MY_BITMAP *map, const MY_BITMAP *map2); +extern uint bitmap_lock_set_next(MY_BITMAP *map); +extern void bitmap_lock_clear_bit(MY_BITMAP *map, uint bitmap_bit); +static inline void +bitmap_set_bit(MY_BITMAP *map,uint bit) +{ + assert(bit < (map)->n_bits); + (((uchar*)(map)->bitmap)[(bit) / 8] |= (1 << ((bit) & 7))); +} +static inline void +bitmap_flip_bit(MY_BITMAP *map,uint bit) +{ + assert(bit < (map)->n_bits); + (((uchar*)(map)->bitmap)[(bit) / 8] ^= (1 << ((bit) & 7))); +} +static inline void +bitmap_clear_bit(MY_BITMAP *map,uint bit) +{ + assert(bit < (map)->n_bits); + (((uchar*)(map)->bitmap)[(bit) / 8] &= ~ (1 << ((bit) & 7))); +} +static inline uint +bitmap_is_set(const MY_BITMAP *map,uint bit) +{ + assert(bit < (map)->n_bits); + return (uint) (((uchar*)(map)->bitmap)[(bit) / 8] & (1 << ((bit) & 7))); +} +static inline my_bool bitmap_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2) +{ + *(map1)->last_word_ptr|= (map1)->last_word_mask; + *(map2)->last_word_ptr|= (map2)->last_word_mask; + return memcmp((map1)->bitmap, (map2)->bitmap, 4*((((map1))->n_bits + 31)/32))==0; +} +template <uint default_width> class Bitmap +{ + MY_BITMAP map; + uint32 buffer[(default_width+31)/32]; +public: + Bitmap() { init(); } + Bitmap(const Bitmap& from) { *this=from; } + explicit Bitmap(uint prefix_to_set) { init(prefix_to_set); } + void init() { bitmap_init(&map, buffer, default_width, 0); } + void init(uint prefix_to_set) { init(); set_prefix(prefix_to_set); } + uint length() const { return default_width; } + Bitmap& operator=(const Bitmap& map2) + { + init(); + memcpy(buffer, map2.buffer, sizeof(buffer)); + return *this; + } + void set_bit(uint n) { bitmap_set_bit(&map, n); } + void clear_bit(uint n) { bitmap_clear_bit(&map, n); } + void set_prefix(uint n) { bitmap_set_prefix(&map, n); } + void set_all() { (memset((&map)->bitmap, 0xFF, 4*((((&map))->n_bits + 31)/32))); } + void clear_all() { { memset((&map)->bitmap, 0, 4*((((&map))->n_bits + 31)/32)); }; } + void intersect(Bitmap& map2) { bitmap_intersect(&map, &map2.map); } + void intersect(ulonglong map2buff) + { + MY_BITMAP map2; + bitmap_init(&map2, (uint32 *)&map2buff, sizeof(ulonglong)*8, 0); + bitmap_intersect(&map, &map2); + } + void intersect_extended(ulonglong map2buff) + { + intersect(map2buff); + if (map.n_bits > sizeof(ulonglong) * 8) + bitmap_set_above(&map, sizeof(ulonglong), + ((map2buff & (1LL << (sizeof(ulonglong) * 8 - 1))) ? 1 : 0)); + } + void subtract(Bitmap& map2) { bitmap_subtract(&map, &map2.map); } + void merge(Bitmap& map2) { bitmap_union(&map, &map2.map); } + my_bool is_set(uint n) const { return bitmap_is_set(&map, n); } + my_bool is_prefix(uint n) const { return bitmap_is_prefix(&map, n); } + my_bool is_clear_all() const { return bitmap_is_clear_all(&map); } + my_bool is_set_all() const { return bitmap_is_set_all(&map); } + my_bool is_subset(const Bitmap& map2) const { return bitmap_is_subset(&map, &map2.map); } + my_bool is_overlapping(const Bitmap& map2) const { return bitmap_is_overlapping(&map, &map2.map); } + my_bool operator==(const Bitmap& map2) const { return bitmap_cmp(&map, &map2.map); } + char *print(char *buf) const + { + char *s=buf; + const uchar *e=(uchar *)buffer, *b=e+sizeof(buffer)-1; + while (!*b && b>e) + b--; + if ((*s=_dig_vec_upper[*b >> 4]) != '0') + s++; + *s++=_dig_vec_upper[*b & 15]; + while (--b>=e) + { + *s++=_dig_vec_upper[*b >> 4]; + *s++=_dig_vec_upper[*b & 15]; + } + *s=0; + return buf; + } + ulonglong to_ulonglong() const + { + if (sizeof(buffer) >= 8) + return (*((ulonglong *) (buffer))); + assert(sizeof(buffer) >= 4); + return (ulonglong) (*((uint32 *) (buffer))); + } +}; +template <> class Bitmap<64> +{ + ulonglong map; +public: + Bitmap<64>() { } + explicit Bitmap<64>(uint prefix_to_set) { set_prefix(prefix_to_set); } + void init() { } + void init(uint prefix_to_set) { set_prefix(prefix_to_set); } + uint length() const { return 64; } + void set_bit(uint n) { map|= ((ulonglong)1) << n; } + void clear_bit(uint n) { map&= ~(((ulonglong)1) << n); } + void set_prefix(uint n) + { + if (n >= length()) + set_all(); + else + map= (((ulonglong)1) << n)-1; + } + void set_all() { map=~(ulonglong)0; } + void clear_all() { map=(ulonglong)0; } + void intersect(Bitmap<64>& map2) { map&= map2.map; } + void intersect(ulonglong map2) { map&= map2; } + void intersect_extended(ulonglong map2) { map&= map2; } + void subtract(Bitmap<64>& map2) { map&= ~map2.map; } + void merge(Bitmap<64>& map2) { map|= map2.map; } + my_bool is_set(uint n) const { return ((map & (((ulonglong)1) << n)) ? 1 : 0); } + my_bool is_prefix(uint n) const { return map == (((ulonglong)1) << n)-1; } + my_bool is_clear_all() const { return map == (ulonglong)0; } + my_bool is_set_all() const { return map == ~(ulonglong)0; } + my_bool is_subset(const Bitmap<64>& map2) const { return !(map & ~map2.map); } + my_bool is_overlapping(const Bitmap<64>& map2) const { return (map & map2.map)!= 0; } + my_bool operator==(const Bitmap<64>& map2) const { return map == map2.map; } + char *print(char *buf) const { longlong2str(map,buf,16); return buf; } + ulonglong to_ulonglong() const { return map; } +}; +#include "sql_array.h" +#include <my_sys.h> +template <class Elem> class Dynamic_array +{ + DYNAMIC_ARRAY array; +public: + Dynamic_array(uint prealloc=16, uint increment=16) + { + init_dynamic_array2(&array,sizeof(Elem),NULL,prealloc,increment ); + } + Elem& at(int idx) + { + return *(((Elem*)array.buffer) + idx); + } + Elem *front() + { + return (Elem*)array.buffer; + } + Elem *back() + { + return ((Elem*)array.buffer) + array.elements; + } + In_C_you_should_use_my_bool_instead() append(Elem &el) + { + return (insert_dynamic(&array, (uchar*)&el)); + } + int elements() + { + return array.elements; + } + ~Dynamic_array() + { + delete_dynamic(&array); + } + typedef int (*CMP_FUNC)(const Elem *el1, const Elem *el2); + void sort(CMP_FUNC cmp_func) + { + my_qsort(array.buffer, array.elements, sizeof(Elem), (qsort_cmp)cmp_func); + } +}; +#include "sql_plugin.h" +class sys_var; +#include <mysql/plugin.h> +typedef struct st_mysql_lex_string MYSQL_LEX_STRING; +struct st_mysql_xid { + long formatID; + long gtrid_length; + long bqual_length; + char data[128]; +}; +typedef struct st_mysql_xid MYSQL_XID; +enum enum_mysql_show_type +{ + SHOW_UNDEF, SHOW_BOOL, SHOW_INT, SHOW_LONG, + SHOW_LONGLONG, SHOW_CHAR, SHOW_CHAR_PTR, + SHOW_ARRAY, SHOW_FUNC, SHOW_KEY_CACHE_LONG, SHOW_KEY_CACHE_LONGLONG, SHOW_LONG_STATUS, SHOW_DOUBLE_STATUS, SHOW_HAVE, SHOW_MY_BOOL, SHOW_HA_ROWS, SHOW_SYS, SHOW_LONG_NOFLUSH, SHOW_LONGLONG_STATUS, SHOW_DOUBLE +}; +struct st_mysql_show_var { + const char *name; + char *value; + enum enum_mysql_show_type type; +}; +typedef int (*mysql_show_var_func)(void*, struct st_mysql_show_var*, char *); +struct st_mysql_sys_var; +struct st_mysql_value; +typedef int (*mysql_var_check_func)(void* thd, + struct st_mysql_sys_var *var, + void *save, struct st_mysql_value *value); +typedef void (*mysql_var_update_func)(void* thd, + struct st_mysql_sys_var *var, + void *var_ptr, const void *save); +struct st_mysql_plugin +{ + int type; + void *info; + const char *name; + const char *author; + const char *descr; + int license; + int (*init)(void *); + int (*deinit)(void *); + unsigned int version; + struct st_mysql_show_var *status_vars; + struct st_mysql_sys_var **system_vars; + void * __reserved1; +}; +enum enum_ftparser_mode +{ + MYSQL_FTPARSER_SIMPLE_MODE= 0, + MYSQL_FTPARSER_WITH_STOPWORDS= 1, + MYSQL_FTPARSER_FULL_BOOLEAN_INFO= 2 +}; +enum enum_ft_token_type +{ + FT_TOKEN_EOF= 0, + FT_TOKEN_WORD= 1, + FT_TOKEN_LEFT_PAREN= 2, + FT_TOKEN_RIGHT_PAREN= 3, + FT_TOKEN_STOPWORD= 4 +}; +typedef struct st_mysql_ftparser_boolean_info +{ + enum enum_ft_token_type type; + int yesno; + int weight_adjust; + char wasign; + char trunc; + char prev; + char *quot; +} MYSQL_FTPARSER_BOOLEAN_INFO; +typedef struct st_mysql_ftparser_param +{ + int (*mysql_parse)(struct st_mysql_ftparser_param *, + char *doc, int doc_len); + int (*mysql_add_word)(struct st_mysql_ftparser_param *, + char *word, int word_len, + MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info); + void *ftparser_state; + void *mysql_ftparam; + struct charset_info_st *cs; + char *doc; + int length; + int flags; + enum enum_ftparser_mode mode; +} MYSQL_FTPARSER_PARAM; +struct st_mysql_ftparser +{ + int interface_version; + int (*parse)(MYSQL_FTPARSER_PARAM *param); + int (*init)(MYSQL_FTPARSER_PARAM *param); + int (*deinit)(MYSQL_FTPARSER_PARAM *param); +}; +struct st_mysql_storage_engine +{ + int interface_version; +}; +struct handlerton; +struct st_mysql_daemon +{ + int interface_version; +}; +struct st_mysql_information_schema +{ + int interface_version; +}; +struct st_mysql_value +{ + int (*value_type)(struct st_mysql_value *); + const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length); + int (*val_real)(struct st_mysql_value *, double *realbuf); + int (*val_int)(struct st_mysql_value *, long long *intbuf); +}; +int thd_in_lock_tables(const void* thd); +int thd_tablespace_op(const void* thd); +long long thd_test_options(const void* thd, long long test_options); +int thd_sql_command(const void* thd); +const char *thd_proc_info(void* thd, const char *info); +void **thd_ha_data(const void* thd, const struct handlerton *hton); +int thd_tx_isolation(const void* thd); +char *thd_security_context(void* thd, char *buffer, unsigned int length, + unsigned int max_query_len); +void thd_inc_row_count(void* thd); +int mysql_tmpfile(const char *prefix); +int thd_killed(const void* thd); +unsigned long thd_get_thread_id(const void* thd); +void *thd_alloc(void* thd, unsigned int size); +void *thd_calloc(void* thd, unsigned int size); +char *thd_strdup(void* thd, const char *str); +char *thd_strmake(void* thd, const char *str, unsigned int size); +void *thd_memdup(void* thd, const void* str, unsigned int size); +MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str, + const char *str, unsigned int size, + int allocate_lex_string); +void thd_get_xid(const void* thd, MYSQL_XID *xid); +void mysql_query_cache_invalidate4(void* thd, + const char *key, unsigned int key_length, + int using_trx); +typedef enum enum_mysql_show_type SHOW_TYPE; +typedef struct st_mysql_show_var SHOW_VAR; +struct st_plugin_dl +{ + LEX_STRING dl; + void *handle; + struct st_mysql_plugin *plugins; + int version; + uint ref_count; +}; +struct st_plugin_int +{ + LEX_STRING name; + struct st_mysql_plugin *plugin; + struct st_plugin_dl *plugin_dl; + uint state; + uint ref_count; + void *data; + MEM_ROOT mem_root; + sys_var *system_vars; +}; +typedef struct st_plugin_int **plugin_ref; +typedef int (*plugin_type_init)(struct st_plugin_int *); +extern char *opt_plugin_load; +extern char *opt_plugin_dir_ptr; +extern char opt_plugin_dir[512]; +extern const LEX_STRING plugin_type_names[]; +extern int plugin_init(int *argc, char **argv, int init_flags); +extern void plugin_shutdown(void); +extern void my_print_help_inc_plugins(struct my_option *options, uint size); +extern In_C_you_should_use_my_bool_instead() plugin_is_ready(const LEX_STRING *name, int type); +extern plugin_ref plugin_lock(THD *thd, plugin_ref *ptr ); +extern plugin_ref plugin_lock_by_name(THD *thd, const LEX_STRING *name, + int type ); +extern void plugin_unlock(THD *thd, plugin_ref plugin); +extern void plugin_unlock_list(THD *thd, plugin_ref *list, uint count); +extern In_C_you_should_use_my_bool_instead() mysql_install_plugin(THD *thd, const LEX_STRING *name, + const LEX_STRING *dl); +extern In_C_you_should_use_my_bool_instead() mysql_uninstall_plugin(THD *thd, const LEX_STRING *name); +extern In_C_you_should_use_my_bool_instead() plugin_register_builtin(struct st_mysql_plugin *plugin); +extern void plugin_thdvar_init(THD *thd); +extern void plugin_thdvar_cleanup(THD *thd); +typedef my_bool (plugin_foreach_func)(THD *thd, + plugin_ref plugin, + void *arg); +extern In_C_you_should_use_my_bool_instead() plugin_foreach_with_mask(THD *thd, plugin_foreach_func *func, + int type, uint state_mask, void *arg); +#include "scheduler.h" +class THD; +class scheduler_functions +{ +public: + uint max_threads; + In_C_you_should_use_my_bool_instead() (*init)(void); + In_C_you_should_use_my_bool_instead() (*init_new_connection_thread)(void); + void (*add_connection)(THD *thd); + void (*post_kill_notification)(THD *thd); + In_C_you_should_use_my_bool_instead() (*end_thread)(THD *thd, In_C_you_should_use_my_bool_instead() cache_thread); + void (*end)(void); + scheduler_functions(); +}; +enum scheduler_types +{ + SCHEDULER_ONE_THREAD_PER_CONNECTION=0, + SCHEDULER_NO_THREADS, + SCHEDULER_POOL_OF_THREADS +}; +void one_thread_per_connection_scheduler(scheduler_functions* func); +void one_thread_scheduler(scheduler_functions* func); +enum pool_command_op +{ + NOT_IN_USE_OP= 0, NORMAL_OP= 1, CONNECT_OP, KILL_OP, DIE_OP +}; +class thd_scheduler +{}; +enum enum_query_type +{ + QT_ORDINARY, + QT_IS +}; +typedef ulonglong table_map; +typedef Bitmap<64> key_map; +typedef ulong nesting_map; +typedef ulonglong nested_join_map; +typedef ulonglong query_id_t; +extern query_id_t global_query_id; +inline query_id_t next_query_id() { return global_query_id++; } +extern const key_map key_map_empty; +extern key_map key_map_full; +extern const char *primary_key_name; +#include "mysql_com.h" +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, COM_DAEMON, + COM_END +}; +struct st_vio; +typedef struct st_vio Vio; +typedef struct st_net { + Vio *vio; + unsigned char *buff,*buff_end,*write_pos,*read_pos; + my_socket fd; + unsigned long remain_in_buf,length, buf_length, where_b; + unsigned long max_packet,max_packet_size; + unsigned int pkt_nr,compress_pkt_nr; + unsigned int write_timeout, read_timeout, retry_count; + int fcntl; + unsigned int *return_status; + unsigned char reading_or_writing; + char save_char; + my_bool unused0; + my_bool unused; + my_bool compress; + my_bool unused1; + unsigned char *query_cache_query; + unsigned int last_errno; + unsigned char error; + my_bool unused2; + my_bool return_errno; + char last_error[512]; + char sqlstate[5 +1]; + void *extension; +} NET; +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 +}; +enum mysql_enum_shutdown_level { + SHUTDOWN_DEFAULT = 0, + SHUTDOWN_WAIT_CONNECTIONS= (unsigned char)(1 << 0), + SHUTDOWN_WAIT_TRANSACTIONS= (unsigned char)(1 << 1), + SHUTDOWN_WAIT_UPDATES= (unsigned char)(1 << 3), + SHUTDOWN_WAIT_ALL_BUFFERS= ((unsigned char)(1 << 3) << 1), + SHUTDOWN_WAIT_CRITICAL_BUFFERS= ((unsigned char)(1 << 3) << 1) + 1, + KILL_QUERY= 254, + 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 +}; +enum enum_mysql_set_option +{ + MYSQL_OPTION_MULTI_STATEMENTS_ON, + MYSQL_OPTION_MULTI_STATEMENTS_OFF +}; +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 clear_buffer); +my_bool net_realloc(NET *net, size_t length); +my_bool net_flush(NET *net); +my_bool my_net_write(NET *net,const unsigned char *packet, size_t len); +my_bool net_write_command(NET *net,unsigned char command, + const unsigned char *header, size_t head_len, + const unsigned char *packet, size_t len); +int net_real_write(NET *net,const unsigned char *packet, size_t len); +unsigned long my_net_read(NET *net); +void my_net_set_write_timeout(NET *net, uint timeout); +void my_net_set_read_timeout(NET *net, uint timeout); +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; +}; +enum Item_result {STRING_RESULT=0, REAL_RESULT, INT_RESULT, ROW_RESULT, + DECIMAL_RESULT}; +typedef struct st_udf_args +{ + unsigned int arg_count; + enum Item_result *arg_type; + char **args; + unsigned long *lengths; + char *maybe_null; + char **attributes; + unsigned long *attribute_lengths; + void *extension; +} UDF_ARGS; +typedef struct st_udf_init +{ + my_bool maybe_null; + unsigned int decimals; + unsigned long max_length; + char *ptr; + my_bool const_item; + void *extension; +} UDF_INIT; +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); +char *get_tty_password(const char *opt_message); +const char *mysql_errno_to_sqlstate(unsigned int mysql_errno); +my_bool my_thread_init(void); +void my_thread_end(void); +ulong net_field_length(uchar **packet); +my_ulonglong net_field_length_ll(uchar **packet); +uchar *net_store_length(uchar *pkg, ulonglong length); +#include <violite.h> +#include "my_net.h" +#include <errno.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <sys/poll.h> +#include <sys/ioctl.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/tcp.h> +void my_inet_ntoa(struct in_addr in, char *buf); +struct hostent; +struct hostent *my_gethostbyname_r(const char *name, + struct hostent *result, char *buffer, + int buflen, int *h_errnop); +enum enum_vio_type +{ + VIO_CLOSED, VIO_TYPE_TCPIP, VIO_TYPE_SOCKET, VIO_TYPE_NAMEDPIPE, + VIO_TYPE_SSL, VIO_TYPE_SHARED_MEMORY +}; +Vio* vio_new(my_socket sd, enum enum_vio_type type, uint flags); +void vio_delete(Vio* vio); +int vio_close(Vio* vio); +void vio_reset(Vio* vio, enum enum_vio_type type, + my_socket sd, void * hPipe, uint flags); +size_t vio_read(Vio *vio, uchar * buf, size_t size); +size_t vio_read_buff(Vio *vio, uchar * buf, size_t size); +size_t vio_write(Vio *vio, const uchar * buf, size_t size); +int vio_blocking(Vio *vio, my_bool onoff, my_bool *old_mode); +my_bool vio_is_blocking(Vio *vio); +int vio_fastsend(Vio *vio); +int vio_keepalive(Vio *vio, my_bool onoff); +my_bool vio_should_retry(Vio *vio); +my_bool vio_was_interrupted(Vio *vio); +const char* vio_description(Vio *vio); +enum enum_vio_type vio_type(Vio* vio); +int vio_errno(Vio*vio); +my_socket vio_fd(Vio*vio); +my_bool vio_peer_addr(Vio* vio, char *buf, uint16 *port); +void vio_in_addr(Vio *vio, struct in_addr *in); +my_bool vio_poll_read(Vio *vio,uint timeout); +void vio_end(void); +enum SSL_type +{ + SSL_TYPE_NOT_SPECIFIED= -1, + SSL_TYPE_NONE, + SSL_TYPE_ANY, + SSL_TYPE_X509, + SSL_TYPE_SPECIFIED +}; +struct st_vio +{ + my_socket sd; + void * hPipe; + my_bool localhost; + int fcntl_mode; + struct sockaddr_in local; + struct sockaddr_in remote; + enum enum_vio_type type; + char desc[30]; + char *read_buffer; + char *read_pos; + char *read_end; + void (*viodelete)(Vio*); + int (*vioerrno)(Vio*); + size_t (*read)(Vio*, uchar *, size_t); + size_t (*write)(Vio*, const uchar *, size_t); + int (*vioblocking)(Vio*, my_bool, my_bool *); + my_bool (*is_blocking)(Vio*); + int (*viokeepalive)(Vio*, my_bool); + int (*fastsend)(Vio*); + my_bool (*peer_addr)(Vio*, char *, uint16*); + void (*in_addr)(Vio*, struct in_addr*); + my_bool (*should_retry)(Vio*); + my_bool (*was_interrupted)(Vio*); + int (*vioclose)(Vio*); + void (*timeout)(Vio*, unsigned int which, unsigned int timeout); +}; +#include "unireg.h" +#include "mysqld_error.h" +#include "structs.h" +struct st_table; +class Field; +typedef struct st_date_time_format { + uchar positions[8]; + char time_separator; + uint flag; + LEX_STRING format; +} DATE_TIME_FORMAT; +typedef struct st_keyfile_info { + uchar ref[8]; + uchar dupp_ref[8]; + uint ref_length; + uint block_size; + File filenr; + ha_rows records; + ha_rows deleted; + ulonglong data_file_length; + ulonglong max_data_file_length; + ulonglong index_file_length; + ulonglong max_index_file_length; + ulonglong delete_length; + ulonglong auto_increment_value; + int errkey,sortkey; + time_t create_time; + time_t check_time; + time_t update_time; + ulong mean_rec_length; +} KEYFILE_INFO; +typedef struct st_key_part_info { + Field *field; + uint offset; + uint null_offset; + uint16 length; + uint16 store_length; + uint16 key_type; + uint16 fieldnr; + uint16 key_part_flag; + uint8 type; + uint8 null_bit; +} KEY_PART_INFO ; +typedef struct st_key { + uint key_length; + ulong flags; + uint key_parts; + uint extra_length; + uint usable_key_parts; + uint block_size; + enum ha_key_alg algorithm; + union + { + plugin_ref parser; + LEX_STRING *parser_name; + }; + KEY_PART_INFO *key_part; + char *name; + ulong *rec_per_key; + union { + int bdb_return_if_eq; + } handler; + struct st_table *table; +} KEY; +struct st_join_table; +typedef struct st_reginfo { + struct st_join_table *join_tab; + enum thr_lock_type lock_type; + In_C_you_should_use_my_bool_instead() not_exists_optimize; + In_C_you_should_use_my_bool_instead() impossible_range; +} REGINFO; +struct st_read_record; +class SQL_SELECT; +class THD; +class handler; +typedef struct st_read_record { + struct st_table *table; + handler *file; + struct st_table **forms; + int (*read_record)(struct st_read_record *); + THD *thd; + SQL_SELECT *select; + uint cache_records; + uint ref_length,struct_length,reclength,rec_cache_size,error_offset; + uint index; + uchar *ref_pos; + uchar *record; + uchar *rec_buf; + uchar *cache,*cache_pos,*cache_end,*read_positions; + IO_CACHE *io_cache; + In_C_you_should_use_my_bool_instead() print_error, ignore_not_found_rows; +} READ_RECORD; +typedef enum enum_mysql_timestamp_type timestamp_type; +typedef struct { + ulong year,month,day,hour; + ulonglong minute,second,second_part; + In_C_you_should_use_my_bool_instead() neg; +} INTERVAL; +typedef struct st_known_date_time_format { + const char *format_name; + const char *date_format; + const char *datetime_format; + const char *time_format; +} KNOWN_DATE_TIME_FORMAT; +enum SHOW_COMP_OPTION { SHOW_OPTION_YES, SHOW_OPTION_NO, SHOW_OPTION_DISABLED}; +extern const char *show_comp_option_name[]; +typedef int *(*update_var)(THD *, struct st_mysql_show_var *); +typedef struct st_lex_user { + LEX_STRING user, host, password; +} LEX_USER; +typedef struct user_resources { + uint questions; + uint updates; + uint conn_per_hour; + uint user_conn; + enum {QUERIES_PER_HOUR= 1, UPDATES_PER_HOUR= 2, CONNECTIONS_PER_HOUR= 4, + USER_CONNECTIONS= 8}; + uint specified_limits; +} USER_RESOURCES; +typedef struct user_conn { + char *user; + char *host; + ulonglong reset_utime; + uint len; + uint connections; + uint conn_per_hour, updates, questions; + USER_RESOURCES user_resources; +} USER_CONN; +class Discrete_interval { +private: + ulonglong interval_min; + ulonglong interval_values; + ulonglong interval_max; +public: + Discrete_interval *next; + void replace(ulonglong start, ulonglong val, ulonglong incr) + { + interval_min= start; + interval_values= val; + interval_max= (val == ((unsigned long long)(~0ULL))) ? val : start + val * incr; + } + Discrete_interval(ulonglong start, ulonglong val, ulonglong incr) : + next(NULL) { replace(start, val, incr); }; + Discrete_interval() : next(NULL) { replace(0, 0, 0); }; + ulonglong minimum() const { return interval_min; }; + ulonglong values() const { return interval_values; }; + ulonglong maximum() const { return interval_max; }; + In_C_you_should_use_my_bool_instead() merge_if_contiguous(ulonglong start, ulonglong val, ulonglong incr) + { + if (interval_max == start) + { + if (val == ((unsigned long long)(~0ULL))) + { + interval_values= interval_max= val; + } + else + { + interval_values+= val; + interval_max= start + val * incr; + } + return 0; + } + return 1; + }; +}; +class Discrete_intervals_list { +private: + Discrete_interval *head; + Discrete_interval *tail; + Discrete_interval *current; + uint elements; + void copy_(const Discrete_intervals_list& from) + { + for (Discrete_interval *i= from.head; i; i= i->next) + { + Discrete_interval j= *i; + append(&j); + } + } +public: + Discrete_intervals_list() : head(NULL), current(NULL), elements(0) {}; + Discrete_intervals_list(const Discrete_intervals_list& from) + { + copy_(from); + } + void operator=(const Discrete_intervals_list& from) + { + empty(); + copy_(from); + } + void empty_no_free() + { + head= current= NULL; + elements= 0; + } + void empty() + { + for (Discrete_interval *i= head; i;) + { + Discrete_interval *next= i->next; + delete i; + i= next; + } + empty_no_free(); + } + const Discrete_interval* get_next() + { + Discrete_interval *tmp= current; + if (current != NULL) + current= current->next; + return tmp; + } + ~Discrete_intervals_list() { empty(); }; + In_C_you_should_use_my_bool_instead() append(ulonglong start, ulonglong val, ulonglong incr); + In_C_you_should_use_my_bool_instead() append(Discrete_interval *interval); + ulonglong minimum() const { return (head ? head->minimum() : 0); }; + ulonglong maximum() const { return (head ? tail->maximum() : 0); }; + uint nb_elements() const { return elements; } +}; +void init_sql_alloc(MEM_ROOT *root, uint block_size, uint pre_alloc_size); +void *sql_alloc(size_t); +void *sql_calloc(size_t); +char *sql_strdup(const char *str); +char *sql_strmake(const char *str, size_t len); +void *sql_memdup(const void * ptr, size_t size); +void sql_element_free(void *ptr); +char *sql_strmake_with_convert(const char *str, size_t arg_length, + CHARSET_INFO *from_cs, + size_t max_res_length, + CHARSET_INFO *to_cs, size_t *result_length); +uint kill_one_thread(THD *thd, ulong id, In_C_you_should_use_my_bool_instead() only_kill_query); +void sql_kill(THD *thd, ulong id, In_C_you_should_use_my_bool_instead() only_kill_query); +In_C_you_should_use_my_bool_instead() net_request_file(NET* net, const char* fname); +char* query_table_status(THD *thd,const char *db,const char *table_name); +extern CHARSET_INFO *system_charset_info, *files_charset_info ; +extern CHARSET_INFO *national_charset_info, *table_alias_charset; +enum Derivation +{ + DERIVATION_IGNORABLE= 5, + DERIVATION_COERCIBLE= 4, + DERIVATION_SYSCONST= 3, + DERIVATION_IMPLICIT= 2, + DERIVATION_NONE= 1, + DERIVATION_EXPLICIT= 0 +}; +typedef struct my_locale_st +{ + uint number; + const char *name; + const char *description; + const In_C_you_should_use_my_bool_instead() is_ascii; + TYPELIB *month_names; + TYPELIB *ab_month_names; + TYPELIB *day_names; + TYPELIB *ab_day_names; +} MY_LOCALE; +extern MY_LOCALE my_locale_en_US; +extern MY_LOCALE *my_locales[]; +extern MY_LOCALE *my_default_lc_time_names; +MY_LOCALE *my_locale_by_name(const char *name); +MY_LOCALE *my_locale_by_number(uint number); +class Object_creation_ctx +{ +public: + Object_creation_ctx *set_n_backup(THD *thd); + void restore_env(THD *thd, Object_creation_ctx *backup_ctx); +protected: + Object_creation_ctx() {} + virtual Object_creation_ctx *create_backup_ctx(THD *thd) const = 0; + virtual void change_env(THD *thd) const = 0; +public: + virtual ~Object_creation_ctx() + { } +}; +class Default_object_creation_ctx : public Object_creation_ctx +{ +public: + CHARSET_INFO *get_client_cs() + { + return m_client_cs; + } + CHARSET_INFO *get_connection_cl() + { + return m_connection_cl; + } +protected: + Default_object_creation_ctx(THD *thd); + Default_object_creation_ctx(CHARSET_INFO *client_cs, + CHARSET_INFO *connection_cl); +protected: + virtual Object_creation_ctx *create_backup_ctx(THD *thd) const; + virtual void change_env(THD *thd) const; +protected: + CHARSET_INFO *m_client_cs; + CHARSET_INFO *m_connection_cl; +}; +struct TABLE_LIST; +class String; +void view_store_options(THD *thd, TABLE_LIST *table, String *buff); +enum enum_parsing_place +{ + NO_MATTER, + IN_HAVING, + SELECT_LIST, + IN_WHERE, + IN_ON +}; +struct st_table; +class THD; +enum enum_check_fields +{ + CHECK_FIELD_IGNORE, + CHECK_FIELD_WARN, + CHECK_FIELD_ERROR_FOR_NULL +}; +typedef struct st_sql_list { + uint elements; + uchar *first; + uchar **next; + st_sql_list() {} + inline void empty() + { + elements=0; + first=0; + next= &first; + } + inline void link_in_list(uchar *element,uchar **next_ptr) + { + elements++; + (*next)=element; + next= next_ptr; + *next=0; + } + inline void save_and_clear(struct st_sql_list *save) + { + *save= *this; + empty(); + } + inline void push_front(struct st_sql_list *save) + { + *save->next= first; + first= save->first; + elements+= save->elements; + } + inline void push_back(struct st_sql_list *save) + { + if (save->first) + { + *next= save->first; + next= save->next; + elements+= save->elements; + } + } +} SQL_LIST; +extern pthread_key_t THR_THD; +inline THD *_current_thd(void) +{ + return ((THD*) pthread_getspecific((THR_THD))); +} +extern "C" +const char *set_thd_proc_info(THD *thd, const char *info, + const char *calling_func, + const char *calling_file, + const unsigned int calling_line); +enum enum_table_ref_type +{ + TABLE_REF_NULL= 0, + TABLE_REF_VIEW, + TABLE_REF_BASE_TABLE, + TABLE_REF_I_S_TABLE, + TABLE_REF_TMP_TABLE +}; +extern ulong server_id, concurrency; +typedef my_bool (*qc_engine_callback)(THD *thd, char *table_key, + uint key_length, + ulonglong *engine_data); +#include "sql_string.h" +class String; +int sortcmp(const String *a,const String *b, CHARSET_INFO *cs); +String *copy_if_not_alloced(String *a,String *b,uint32 arg_length); +uint32 copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, + const char *from, uint32 from_length, + CHARSET_INFO *from_cs, uint *errors); +uint32 well_formed_copy_nchars(CHARSET_INFO *to_cs, + char *to, uint to_length, + CHARSET_INFO *from_cs, + const char *from, uint from_length, + uint nchars, + const char **well_formed_error_pos, + const char **cannot_convert_error_pos, + const char **from_end_pos); +size_t my_copy_with_hex_escaping(CHARSET_INFO *cs, + char *dst, size_t dstlen, + const char *src, size_t srclen); +class String +{ + char *Ptr; + uint32 str_length,Alloced_length; + In_C_you_should_use_my_bool_instead() alloced; + CHARSET_INFO *str_charset; +public: + String() + { + Ptr=0; str_length=Alloced_length=0; alloced=0; + str_charset= &my_charset_bin; + } + String(uint32 length_arg) + { + alloced=0; Alloced_length=0; (void) real_alloc(length_arg); + str_charset= &my_charset_bin; + } + String(const char *str, CHARSET_INFO *cs) + { + Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0; + str_charset=cs; + } + String(const char *str,uint32 len, CHARSET_INFO *cs) + { + Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0; + str_charset=cs; + } + String(char *str,uint32 len, CHARSET_INFO *cs) + { + Ptr=(char*) str; Alloced_length=str_length=len; alloced=0; + str_charset=cs; + } + String(const String &str) + { + Ptr=str.Ptr ; str_length=str.str_length ; + Alloced_length=str.Alloced_length; alloced=0; + str_charset=str.str_charset; + } + static void *operator new(size_t size, MEM_ROOT *mem_root) + { return (void*) alloc_root(mem_root, (uint) size); } + static void operator delete(void *ptr_arg,size_t size) + { ; } + static void operator delete(void *ptr_arg, MEM_ROOT *mem_root) + { } + ~String() { free(); } + inline void set_charset(CHARSET_INFO *charset_arg) + { str_charset= charset_arg; } + inline CHARSET_INFO *charset() const { return str_charset; } + inline uint32 length() const { return str_length;} + inline uint32 alloced_length() const { return Alloced_length;} + inline char& operator [] (uint32 i) const { return Ptr[i]; } + inline void length(uint32 len) { str_length=len ; } + inline In_C_you_should_use_my_bool_instead() is_empty() { return (str_length == 0); } + inline void mark_as_const() { Alloced_length= 0;} + inline const char *ptr() const { return Ptr; } + inline char *c_ptr() + { + if (!Ptr || Ptr[str_length]) + (void) realloc(str_length); + return Ptr; + } + inline char *c_ptr_quick() + { + if (Ptr && str_length < Alloced_length) + Ptr[str_length]=0; + return Ptr; + } + inline char *c_ptr_safe() + { + if (Ptr && str_length < Alloced_length) + Ptr[str_length]=0; + else + (void) realloc(str_length); + return Ptr; + } + void set(String &str,uint32 offset,uint32 arg_length) + { + assert(&str != this); + free(); + Ptr=(char*) str.ptr()+offset; str_length=arg_length; alloced=0; + if (str.Alloced_length) + Alloced_length=str.Alloced_length-offset; + else + Alloced_length=0; + str_charset=str.str_charset; + } + inline void set(char *str,uint32 arg_length, CHARSET_INFO *cs) + { + free(); + Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0; + str_charset=cs; + } + inline void set(const char *str,uint32 arg_length, CHARSET_INFO *cs) + { + free(); + Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0; + str_charset=cs; + } + In_C_you_should_use_my_bool_instead() set_ascii(const char *str, uint32 arg_length); + inline void set_quick(char *str,uint32 arg_length, CHARSET_INFO *cs) + { + if (!alloced) + { + Ptr=(char*) str; str_length=Alloced_length=arg_length; + } + str_charset=cs; + } + In_C_you_should_use_my_bool_instead() set_int(longlong num, In_C_you_should_use_my_bool_instead() unsigned_flag, CHARSET_INFO *cs); + In_C_you_should_use_my_bool_instead() set(longlong num, CHARSET_INFO *cs) + { return set_int(num, false, cs); } + In_C_you_should_use_my_bool_instead() set(ulonglong num, CHARSET_INFO *cs) + { return set_int((longlong)num, true, cs); } + In_C_you_should_use_my_bool_instead() set_real(double num,uint decimals, CHARSET_INFO *cs); + inline void chop() + { + Ptr[str_length--]= '\0'; + } + inline void free() + { + if (alloced) + { + alloced=0; + Alloced_length=0; + ((void)(myf) (0),my_no_flags_free(Ptr)); + Ptr=0; + str_length=0; + } + } + inline In_C_you_should_use_my_bool_instead() alloc(uint32 arg_length) + { + if (arg_length < Alloced_length) + return 0; + return real_alloc(arg_length); + } + In_C_you_should_use_my_bool_instead() real_alloc(uint32 arg_length); + In_C_you_should_use_my_bool_instead() realloc(uint32 arg_length); + inline void shrink(uint32 arg_length) + { + if (arg_length < Alloced_length) + { + char *new_ptr; + if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,(myf) (0)))) + { + Alloced_length = 0; + real_alloc(arg_length); + } + else + { + Ptr=new_ptr; + Alloced_length=arg_length; + } + } + } + In_C_you_should_use_my_bool_instead() is_alloced() { return alloced; } + inline String& operator = (const String &s) + { + if (&s != this) + { + assert(!s.uses_buffer_owned_by(this)); + free(); + Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length; + alloced=0; + } + return *this; + } + In_C_you_should_use_my_bool_instead() copy(); + In_C_you_should_use_my_bool_instead() copy(const String &s); + In_C_you_should_use_my_bool_instead() copy(const char *s,uint32 arg_length, CHARSET_INFO *cs); + static In_C_you_should_use_my_bool_instead() needs_conversion(uint32 arg_length, + CHARSET_INFO *cs_from, CHARSET_INFO *cs_to, + uint32 *offset); + In_C_you_should_use_my_bool_instead() copy_aligned(const char *s, uint32 arg_length, uint32 offset, + CHARSET_INFO *cs); + In_C_you_should_use_my_bool_instead() set_or_copy_aligned(const char *s, uint32 arg_length, CHARSET_INFO *cs); + In_C_you_should_use_my_bool_instead() copy(const char*s,uint32 arg_length, CHARSET_INFO *csfrom, + CHARSET_INFO *csto, uint *errors); + In_C_you_should_use_my_bool_instead() append(const String &s); + In_C_you_should_use_my_bool_instead() append(const char *s); + In_C_you_should_use_my_bool_instead() append(const char *s,uint32 arg_length); + In_C_you_should_use_my_bool_instead() append(const char *s,uint32 arg_length, CHARSET_INFO *cs); + In_C_you_should_use_my_bool_instead() append(IO_CACHE* file, uint32 arg_length); + In_C_you_should_use_my_bool_instead() append_with_prefill(const char *s, uint32 arg_length, + uint32 full_length, char fill_char); + int strstr(const String &search,uint32 offset=0); + int strrstr(const String &search,uint32 offset=0); + In_C_you_should_use_my_bool_instead() replace(uint32 offset,uint32 arg_length,const char *to,uint32 length); + In_C_you_should_use_my_bool_instead() replace(uint32 offset,uint32 arg_length,const String &to); + inline In_C_you_should_use_my_bool_instead() append(char chr) + { + if (str_length < Alloced_length) + { + Ptr[str_length++]=chr; + } + else + { + if (realloc(str_length+1)) + return 1; + Ptr[str_length++]=chr; + } + return 0; + } + In_C_you_should_use_my_bool_instead() fill(uint32 max_length,char fill); + void strip_sp(); + friend int sortcmp(const String *a,const String *b, CHARSET_INFO *cs); + friend int stringcmp(const String *a,const String *b); + friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length); + uint32 numchars(); + int charpos(int i,uint32 offset=0); + int reserve(uint32 space_needed) + { + return realloc(str_length + space_needed); + } + int reserve(uint32 space_needed, uint32 grow_by); + void q_append(const char c) + { + Ptr[str_length++] = c; + } + void q_append(const uint32 n) + { + *((long *) (Ptr + str_length))= (long) (n); + str_length += 4; + } + void q_append(double d) + { + do { *((long *) (Ptr + str_length)) = ((doubleget_union *)&(d))->m[0]; *(((long *) (Ptr + str_length))+1) = ((doubleget_union *)&(d))->m[1]; } while (0); + str_length += 8; + } + void q_append(double *d) + { + do { *((long *) (Ptr + str_length)) = ((doubleget_union *)&(*d))->m[0]; *(((long *) (Ptr + str_length))+1) = ((doubleget_union *)&(*d))->m[1]; } while (0); + str_length += 8; + } + void q_append(const char *data, uint32 data_len) + { + memcpy(Ptr + str_length, data, data_len); + str_length += data_len; + } + void write_at_position(int position, uint32 value) + { + *((long *) (Ptr + position))= (long) (value); + } + void qs_append(const char *str, uint32 len); + void qs_append(double d); + void qs_append(double *d); + inline void qs_append(const char c) + { + Ptr[str_length]= c; + str_length++; + } + void qs_append(int i); + void qs_append(uint i); + inline char *prep_append(uint32 arg_length, uint32 step_alloc) + { + uint32 new_length= arg_length + str_length; + if (new_length > Alloced_length) + { + if (realloc(new_length + step_alloc)) + return 0; + } + uint32 old_length= str_length; + str_length+= arg_length; + return Ptr+ old_length; + } + inline In_C_you_should_use_my_bool_instead() append(const char *s, uint32 arg_length, uint32 step_alloc) + { + uint32 new_length= arg_length + str_length; + if (new_length > Alloced_length && realloc(new_length + step_alloc)) + return (1); + memcpy(Ptr+str_length, s, arg_length); + str_length+= arg_length; + return (0); + } + void print(String *print); + void swap(String &s); + inline In_C_you_should_use_my_bool_instead() uses_buffer_owned_by(const String *s) const + { + return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->str_length); + } +}; +static inline In_C_you_should_use_my_bool_instead() check_if_only_end_space(CHARSET_INFO *cs, char *str, + char *end) +{ + return str+ cs->cset->scan(cs, str, end, 2) == end; +} +#include "sql_list.h" +class Sql_alloc +{ +public: + static void *operator new(size_t size) throw () + { + return sql_alloc(size); + } + static void *operator new[](size_t size) + { + return sql_alloc(size); + } + static void *operator new[](size_t size, MEM_ROOT *mem_root) throw () + { return alloc_root(mem_root, size); } + static void *operator new(size_t size, MEM_ROOT *mem_root) throw () + { return alloc_root(mem_root, size); } + static void operator delete(void *ptr, size_t size) { ; } + static void operator delete(void *ptr, MEM_ROOT *mem_root) + { } + static void operator delete[](void *ptr, MEM_ROOT *mem_root) + { } + static void operator delete[](void *ptr, size_t size) { ; } + inline Sql_alloc() {} + inline ~Sql_alloc() {} +}; +struct list_node :public Sql_alloc +{ + list_node *next; + void *info; + list_node(void *info_par,list_node *next_par) + :next(next_par),info(info_par) + {} + list_node() + { + info= 0; + next= this; + } +}; +extern list_node end_of_list; +class base_list :public Sql_alloc +{ +protected: + list_node *first,**last; +public: + uint elements; + inline void empty() { elements=0; first= &end_of_list; last=&first;} + inline base_list() { empty(); } + inline base_list(const base_list &tmp) :Sql_alloc() + { + elements= tmp.elements; + first= tmp.first; + last= elements ? tmp.last : &first; + } + base_list(const base_list &rhs, MEM_ROOT *mem_root); + inline base_list(In_C_you_should_use_my_bool_instead() error) { } + inline In_C_you_should_use_my_bool_instead() push_back(void *info) + { + if (((*last)=new list_node(info, &end_of_list))) + { + last= &(*last)->next; + elements++; + return 0; + } + return 1; + } + inline In_C_you_should_use_my_bool_instead() push_back(void *info, MEM_ROOT *mem_root) + { + if (((*last)=new (mem_root) list_node(info, &end_of_list))) + { + last= &(*last)->next; + elements++; + return 0; + } + return 1; + } + inline In_C_you_should_use_my_bool_instead() push_front(void *info) + { + list_node *node=new list_node(info,first); + if (node) + { + if (last == &first) + last= &node->next; + first=node; + elements++; + return 0; + } + return 1; + } + void remove(list_node **prev) + { + list_node *node=(*prev)->next; + if (!--elements) + last= &first; + else if (last == &(*prev)->next) + last= prev; + delete *prev; + *prev=node; + } + inline void concat(base_list *list) + { + if (!list->is_empty()) + { + *last= list->first; + last= list->last; + elements+= list->elements; + } + } + inline void *pop(void) + { + if (first == &end_of_list) return 0; + list_node *tmp=first; + first=first->next; + if (!--elements) + last= &first; + return tmp->info; + } + inline void disjoin(base_list *list) + { + list_node **prev= &first; + list_node *node= first; + list_node *list_first= list->first; + elements=0; + while (node && node != list_first) + { + prev= &node->next; + node= node->next; + elements++; + } + *prev= *last; + last= prev; + } + inline void prepand(base_list *list) + { + if (!list->is_empty()) + { + *list->last= first; + first= list->first; + elements+= list->elements; + } + } + inline void swap(base_list &rhs) + { + { list_node * dummy; dummy= first; first= rhs.first; rhs.first= dummy; }; + { list_node ** dummy; dummy= last; last= rhs.last; rhs.last= dummy; }; + { uint dummy; dummy= elements; elements= rhs.elements; rhs.elements= dummy; }; + } + inline list_node* last_node() { return *last; } + inline list_node* first_node() { return first;} + inline void *head() { return first->info; } + inline void **head_ref() { return first != &end_of_list ? &first->info : 0; } + inline In_C_you_should_use_my_bool_instead() is_empty() { return first == &end_of_list ; } + inline list_node *last_ref() { return &end_of_list; } + friend class base_list_iterator; + friend class error_list; + friend class error_list_iterator; +protected: + void after(void *info,list_node *node) + { + list_node *new_node=new list_node(info,node->next); + node->next=new_node; + elements++; + if (last == &(node->next)) + last= &new_node->next; + } +}; +class base_list_iterator +{ +protected: + base_list *list; + list_node **el,**prev,*current; + void sublist(base_list &ls, uint elm) + { + ls.first= *el; + ls.last= list->last; + ls.elements= elm; + } +public: + base_list_iterator() + :list(0), el(0), prev(0), current(0) + {} + base_list_iterator(base_list &list_par) + { init(list_par); } + inline void init(base_list &list_par) + { + list= &list_par; + el= &list_par.first; + prev= 0; + current= 0; + } + inline void *next(void) + { + prev=el; + current= *el; + el= ¤t->next; + return current->info; + } + inline void *next_fast(void) + { + list_node *tmp; + tmp= *el; + el= &tmp->next; + return tmp->info; + } + inline void rewind(void) + { + el= &list->first; + } + inline void *replace(void *element) + { + void *tmp=current->info; + assert(current->info != 0); + current->info=element; + return tmp; + } + void *replace(base_list &new_list) + { + void *ret_value=current->info; + if (!new_list.is_empty()) + { + *new_list.last=current->next; + current->info=new_list.first->info; + current->next=new_list.first->next; + if ((list->last == ¤t->next) && (new_list.elements > 1)) + list->last= new_list.last; + list->elements+=new_list.elements-1; + } + return ret_value; + } + inline void remove(void) + { + list->remove(prev); + el=prev; + current=0; + } + void after(void *element) + { + list->after(element,current); + current=current->next; + el= ¤t->next; + } + inline void **ref(void) + { + return ¤t->info; + } + inline In_C_you_should_use_my_bool_instead() is_last(void) + { + return el == &list->last_ref()->next; + } + friend class error_list_iterator; +}; +template <class T> class List :public base_list +{ +public: + inline List() :base_list() {} + inline List(const List<T> &tmp) :base_list(tmp) {} + inline List(const List<T> &tmp, MEM_ROOT *mem_root) : + base_list(tmp, mem_root) {} + inline In_C_you_should_use_my_bool_instead() push_back(T *a) { return base_list::push_back(a); } + inline In_C_you_should_use_my_bool_instead() push_back(T *a, MEM_ROOT *mem_root) + { return base_list::push_back(a, mem_root); } + inline In_C_you_should_use_my_bool_instead() push_front(T *a) { return base_list::push_front(a); } + inline T* head() {return (T*) base_list::head(); } + inline T** head_ref() {return (T**) base_list::head_ref(); } + inline T* pop() {return (T*) base_list::pop(); } + inline void concat(List<T> *list) { base_list::concat(list); } + inline void disjoin(List<T> *list) { base_list::disjoin(list); } + inline void prepand(List<T> *list) { base_list::prepand(list); } + void delete_elements(void) + { + list_node *element,*next; + for (element=first; element != &end_of_list; element=next) + { + next=element->next; + delete (T*) element->info; + } + empty(); + } +}; +template <class T> class List_iterator :public base_list_iterator +{ +public: + List_iterator(List<T> &a) : base_list_iterator(a) {} + List_iterator() : base_list_iterator() {} + inline void init(List<T> &a) { base_list_iterator::init(a); } + inline T* operator++(int) { return (T*) base_list_iterator::next(); } + inline T *replace(T *a) { return (T*) base_list_iterator::replace(a); } + inline T *replace(List<T> &a) { return (T*) base_list_iterator::replace(a); } + inline void rewind(void) { base_list_iterator::rewind(); } + inline void remove() { base_list_iterator::remove(); } + inline void after(T *a) { base_list_iterator::after(a); } + inline T** ref(void) { return (T**) base_list_iterator::ref(); } +}; +template <class T> class List_iterator_fast :public base_list_iterator +{ +protected: + inline T *replace(T *a) { return (T*) 0; } + inline T *replace(List<T> &a) { return (T*) 0; } + inline void remove(void) { } + inline void after(T *a) { } + inline T** ref(void) { return (T**) 0; } +public: + inline List_iterator_fast(List<T> &a) : base_list_iterator(a) {} + inline List_iterator_fast() : base_list_iterator() {} + inline void init(List<T> &a) { base_list_iterator::init(a); } + inline T* operator++(int) { return (T*) base_list_iterator::next_fast(); } + inline void rewind(void) { base_list_iterator::rewind(); } + void sublist(List<T> &list_arg, uint el_arg) + { + base_list_iterator::sublist(list_arg, el_arg); + } +}; +struct ilink +{ + struct ilink **prev,*next; + static void *operator new(size_t size) + { + return (void*)my_malloc((uint)size, (myf) (16 | 8)); + } + static void operator delete(void* ptr_arg, size_t size) + { + ((void)(myf) (16|64),my_no_flags_free((uchar*)ptr_arg)); + } + inline ilink() + { + prev=0; next=0; + } + inline void unlink() + { + if (prev) *prev= next; + if (next) next->prev=prev; + prev=0 ; next=0; + } + virtual ~ilink() { unlink(); } +}; +class i_string: public ilink +{ +public: + const char* ptr; + i_string():ptr(0) { } + i_string(const char* s) : ptr(s) {} +}; +class i_string_pair: public ilink +{ +public: + const char* key; + const char* val; + i_string_pair():key(0),val(0) { } + i_string_pair(const char* key_arg, const char* val_arg) : + key(key_arg),val(val_arg) {} +}; +template <class T> class I_List_iterator; +class base_ilist +{ +public: + struct ilink *first,last; + inline void empty() { first= &last; last.prev= &first; } + base_ilist() { empty(); } + inline In_C_you_should_use_my_bool_instead() is_empty() { return first == &last; } + inline void append(ilink *a) + { + first->prev= &a->next; + a->next=first; a->prev= &first; first=a; + } + inline void push_back(ilink *a) + { + *last.prev= a; + a->next= &last; + a->prev= last.prev; + last.prev= &a->next; + } + inline struct ilink *get() + { + struct ilink *first_link=first; + if (first_link == &last) + return 0; + first_link->unlink(); + return first_link; + } + inline struct ilink *head() + { + return (first != &last) ? first : 0; + } + friend class base_list_iterator; +}; +class base_ilist_iterator +{ + base_ilist *list; + struct ilink **el,*current; +public: + base_ilist_iterator(base_ilist &list_par) :list(&list_par), + el(&list_par.first),current(0) {} + void *next(void) + { + current= *el; + if (current == &list->last) return 0; + el= ¤t->next; + return current; + } +}; +template <class T> +class I_List :private base_ilist +{ +public: + I_List() :base_ilist() {} + inline void empty() { base_ilist::empty(); } + inline In_C_you_should_use_my_bool_instead() is_empty() { return base_ilist::is_empty(); } + inline void append(T* a) { base_ilist::append(a); } + inline void push_back(T* a) { base_ilist::push_back(a); } + inline T* get() { return (T*) base_ilist::get(); } + inline T* head() { return (T*) base_ilist::head(); } + friend class I_List_iterator<T>; +}; +template <class T> class I_List_iterator :public base_ilist_iterator +{ +public: + I_List_iterator(I_List<T> &a) : base_ilist_iterator(a) {} + inline T* operator++(int) { return (T*) base_ilist_iterator::next(); } +}; +template <typename T> +inline +void +list_copy_and_replace_each_value(List<T> &list, MEM_ROOT *mem_root) +{ + List_iterator<T> it(list); + T *el; + while ((el= it++)) + it.replace(el->clone(mem_root)); +} +#include "sql_map.h" +class mapped_files; +mapped_files *map_file(const char * name,uchar *magic,uint magic_length); +void unmap_file(mapped_files *map); +class mapped_files :public ilink { + uchar *map; + ha_rows size; + char *name; + File file; + int error; + uint use_count; +public: + mapped_files(const char * name,uchar *magic,uint magic_length); + ~mapped_files(); + friend class mapped_file; + friend mapped_files *map_file(const char * name,uchar *magic, + uint magic_length); + friend void unmap_file(mapped_files *map); +}; +class mapped_file +{ + mapped_files *file; +public: + mapped_file(const char * name,uchar *magic,uint magic_length) + { + file=map_file(name,magic,magic_length); + } + ~mapped_file() + { + unmap_file(file); + } + uchar *map() + { + return file->map; + } +}; +#include "my_decimal.h" +#include <decimal.h> +typedef enum +{TRUNCATE=0, HALF_EVEN, HALF_UP, CEILING, FLOOR} + decimal_round_mode; +typedef int32 decimal_digit_t; +typedef struct st_decimal_t { + int intg, frac, len; + my_bool sign; + decimal_digit_t *buf; +} decimal_t; +int internal_str2dec(const char *from, decimal_t *to, char **end, + my_bool fixed); +int decimal2string(decimal_t *from, char *to, int *to_len, + int fixed_precision, int fixed_decimals, + char filler); +int decimal2ulonglong(decimal_t *from, ulonglong *to); +int ulonglong2decimal(ulonglong from, decimal_t *to); +int decimal2longlong(decimal_t *from, longlong *to); +int longlong2decimal(longlong from, decimal_t *to); +int decimal2double(decimal_t *from, double *to); +int double2decimal(double from, decimal_t *to); +int decimal_actual_fraction(decimal_t *from); +int decimal2bin(decimal_t *from, uchar *to, int precision, int scale); +int bin2decimal(const uchar *from, decimal_t *to, int precision, int scale); +int decimal_size(int precision, int scale); +int decimal_bin_size(int precision, int scale); +int decimal_result_size(decimal_t *from1, decimal_t *from2, char op, + int param); +int decimal_intg(decimal_t *from); +int decimal_add(decimal_t *from1, decimal_t *from2, decimal_t *to); +int decimal_sub(decimal_t *from1, decimal_t *from2, decimal_t *to); +int decimal_cmp(decimal_t *from1, decimal_t *from2); +int decimal_mul(decimal_t *from1, decimal_t *from2, decimal_t *to); +int decimal_div(decimal_t *from1, decimal_t *from2, decimal_t *to, + int scale_incr); +int decimal_mod(decimal_t *from1, decimal_t *from2, decimal_t *to); +int decimal_round(decimal_t *from, decimal_t *to, int new_scale, + decimal_round_mode mode); +int decimal_is_zero(decimal_t *from); +void max_decimal(int precision, int frac, decimal_t *to); +inline uint my_decimal_size(uint precision, uint scale) +{ + return decimal_size(precision, scale) + 1; +} +inline int my_decimal_int_part(uint precision, uint decimals) +{ + return precision - ((decimals == 31) ? 0 : decimals); +} +class my_decimal :public decimal_t +{ + decimal_digit_t buffer[9]; +public: + void init() + { + len= 9; + buf= buffer; + for (uint i= 0; i < 9; i++) + buffer[i]= i; + } + my_decimal() + { + init(); + } + void fix_buffer_pointer() { buf= buffer; } + In_C_you_should_use_my_bool_instead() sign() const { return decimal_t::sign; } + void sign(In_C_you_should_use_my_bool_instead() s) { decimal_t::sign= s; } + uint precision() const { return intg + frac; } + void swap(my_decimal &rhs) + { + { my_decimal dummy; dummy= *this; *this= rhs; rhs= dummy; }; + { decimal_digit_t * dummy; dummy= buf; buf= rhs.buf; rhs.buf= dummy; }; + } +}; +void print_decimal(const my_decimal *dec); +void print_decimal_buff(const my_decimal *dec, const uchar* ptr, int length); +const char *dbug_decimal_as_string(char *buff, const my_decimal *val); +int decimal_operation_results(int result); +inline +void max_my_decimal(my_decimal *to, int precision, int frac) +{ + assert((precision <= ((9 * 9) - 8*2))&& (frac <= 30)); + max_decimal(precision, frac, (decimal_t*) to); +} +inline void max_internal_decimal(my_decimal *to) +{ + max_my_decimal(to, ((9 * 9) - 8*2), 0); +} +inline int check_result(uint mask, int result) +{ + if (result & mask) + decimal_operation_results(result); + return result; +} +inline int check_result_and_overflow(uint mask, int result, my_decimal *val) +{ + if (check_result(mask, result) & 2) + { + In_C_you_should_use_my_bool_instead() sign= val->sign(); + val->fix_buffer_pointer(); + max_internal_decimal(val); + val->sign(sign); + } + return result; +} +inline uint my_decimal_length_to_precision(uint length, uint scale, + In_C_you_should_use_my_bool_instead() unsigned_flag) +{ + assert(length || !scale); + return (uint) (length - (scale>0 ? 1:0) - + (unsigned_flag || !length ? 0:1)); +} +inline uint32 my_decimal_precision_to_length(uint precision, uint8 scale, + In_C_you_should_use_my_bool_instead() unsigned_flag) +{ + assert(precision || !scale); + do { if ((precision) > (((9 * 9) - 8*2))) (precision)=(((9 * 9) - 8*2)); } while(0); + return (uint32)(precision + (scale>0 ? 1:0) + + (unsigned_flag || !precision ? 0:1)); +} +inline +int my_decimal_string_length(const my_decimal *d) +{ + return (((d)->intg ? (d)->intg : 1) + (d)->frac + ((d)->frac > 0) + 2); +} +inline +int my_decimal_max_length(const my_decimal *d) +{ + return (((d)->intg ? (d)->intg : 1) + (d)->frac + ((d)->frac > 0) + 2) - 1; +} +inline +int my_decimal_get_binary_size(uint precision, uint scale) +{ + return decimal_bin_size((int)precision, (int)scale); +} +inline +void my_decimal2decimal(const my_decimal *from, my_decimal *to) +{ + *to= *from; + to->fix_buffer_pointer(); +} +int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec, + int scale); +inline +int binary2my_decimal(uint mask, const uchar *bin, my_decimal *d, int prec, + int scale) +{ + return check_result(mask, bin2decimal(bin, (decimal_t*) d, prec, scale)); +} +inline +int my_decimal_set_zero(my_decimal *d) +{ + do { (((decimal_t*) d))->buf[0]=0; (((decimal_t*) d))->intg=1; (((decimal_t*) d))->frac=0; (((decimal_t*) d))->sign=0; } while(0); + return 0; +} +inline +In_C_you_should_use_my_bool_instead() my_decimal_is_zero(const my_decimal *decimal_value) +{ + return decimal_is_zero((decimal_t*) decimal_value); +} +inline +int my_decimal_round(uint mask, const my_decimal *from, int scale, + In_C_you_should_use_my_bool_instead() truncate, my_decimal *to) +{ + return check_result(mask, decimal_round((decimal_t*) from, to, scale, + (truncate ? TRUNCATE : HALF_UP))); +} +inline +int my_decimal_floor(uint mask, const my_decimal *from, my_decimal *to) +{ + return check_result(mask, decimal_round((decimal_t*) from, to, 0, FLOOR)); +} +inline +int my_decimal_ceiling(uint mask, const my_decimal *from, my_decimal *to) +{ + return check_result(mask, decimal_round((decimal_t*) from, to, 0, CEILING)); +} +int my_decimal2string(uint mask, const my_decimal *d, uint fixed_prec, + uint fixed_dec, char filler, String *str); +inline +int my_decimal2int(uint mask, const my_decimal *d, my_bool unsigned_flag, + longlong *l) +{ + my_decimal rounded; + decimal_round((decimal_t*)d, &rounded, 0, HALF_UP); + return check_result(mask, (unsigned_flag ? + decimal2ulonglong(&rounded, (ulonglong *)l) : + decimal2longlong(&rounded, l))); +} +inline +int my_decimal2double(uint mask, const my_decimal *d, double *result) +{ + return decimal2double((decimal_t*) d, result); +} +inline +int str2my_decimal(uint mask, const char *str, my_decimal *d, char **end) +{ + return check_result_and_overflow(mask, internal_str2dec((str), ((decimal_t*)d), (end), 0), + d); +} +int str2my_decimal(uint mask, const char *from, uint length, + CHARSET_INFO *charset, my_decimal *decimal_value); +inline +int double2my_decimal(uint mask, double val, my_decimal *d) +{ + return check_result_and_overflow(mask, double2decimal(val, (decimal_t*)d), d); +} +inline +int int2my_decimal(uint mask, longlong i, my_bool unsigned_flag, my_decimal *d) +{ + return check_result(mask, (unsigned_flag ? + ulonglong2decimal((ulonglong)i, d) : + longlong2decimal(i, d))); +} +inline +void my_decimal_neg(decimal_t *arg) +{ + if (decimal_is_zero(arg)) + { + arg->sign= 0; + return; + } + do { (arg)->sign^=1; } while(0); +} +inline +int my_decimal_add(uint mask, my_decimal *res, const my_decimal *a, + const my_decimal *b) +{ + return check_result_and_overflow(mask, + decimal_add((decimal_t*)a,(decimal_t*)b,res), + res); +} +inline +int my_decimal_sub(uint mask, my_decimal *res, const my_decimal *a, + const my_decimal *b) +{ + return check_result_and_overflow(mask, + decimal_sub((decimal_t*)a,(decimal_t*)b,res), + res); +} +inline +int my_decimal_mul(uint mask, my_decimal *res, const my_decimal *a, + const my_decimal *b) +{ + return check_result_and_overflow(mask, + decimal_mul((decimal_t*)a,(decimal_t*)b,res), + res); +} +inline +int my_decimal_div(uint mask, my_decimal *res, const my_decimal *a, + const my_decimal *b, int div_scale_inc) +{ + return check_result_and_overflow(mask, + decimal_div((decimal_t*)a,(decimal_t*)b,res, + div_scale_inc), + res); +} +inline +int my_decimal_mod(uint mask, my_decimal *res, const my_decimal *a, + const my_decimal *b) +{ + return check_result_and_overflow(mask, + decimal_mod((decimal_t*)a,(decimal_t*)b,res), + res); +} +inline +int my_decimal_cmp(const my_decimal *a, const my_decimal *b) +{ + return decimal_cmp((decimal_t*) a, (decimal_t*) b); +} +inline +int my_decimal_intg(const my_decimal *a) +{ + return decimal_intg((decimal_t*) a); +} +void my_decimal_trim(ulong *precision, uint *scale); +#include "handler.h" +#include <my_handler.h> +#include "myisampack.h" +typedef struct st_HA_KEYSEG +{ + CHARSET_INFO *charset; + uint32 start; + uint32 null_pos; + uint16 bit_pos; + uint16 flag; + uint16 length; + uint8 type; + uint8 language; + uint8 null_bit; + uint8 bit_start,bit_end; + uint8 bit_length; +} HA_KEYSEG; +extern int ha_compare_text(CHARSET_INFO *, uchar *, uint, uchar *, uint , + my_bool, my_bool); +extern int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a, + register uchar *b, uint key_length, uint nextflag, + uint *diff_pos); +extern HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, uchar *a); +extern void my_handler_error_register(void); +extern void my_handler_error_unregister(void); +#include <ft_global.h> +typedef struct st_ft_info FT_INFO; +struct _ft_vft +{ + int (*read_next)(FT_INFO *, char *); + float (*find_relevance)(FT_INFO *, uchar *, uint); + void (*close_search)(FT_INFO *); + float (*get_relevance)(FT_INFO *); + void (*reinit_search)(FT_INFO *); +}; +struct st_ft_info +{ + struct _ft_vft *please; +}; +extern const char *ft_stopword_file; +extern const char *ft_precompiled_stopwords[]; +extern ulong ft_min_word_len; +extern ulong ft_max_word_len; +extern ulong ft_query_expansion_limit; +extern char ft_boolean_syntax[15]; +extern struct st_mysql_ftparser ft_default_parser; +int ft_init_stopwords(void); +void ft_free_stopwords(void); +FT_INFO *ft_init_search(uint,void *, uint, uchar *, uint,CHARSET_INFO *, uchar *); +my_bool ft_boolean_check_syntax_string(const uchar *); +#include <keycache.h> +struct st_block_link; +typedef struct st_block_link BLOCK_LINK; +struct st_keycache_page; +typedef struct st_keycache_page KEYCACHE_PAGE; +struct st_hash_link; +typedef struct st_hash_link HASH_LINK; +typedef struct st_keycache_wqueue +{ + struct st_my_thread_var *last_thread; +} KEYCACHE_WQUEUE; +typedef struct st_key_cache +{ + my_bool key_cache_inited; + my_bool in_resize; + my_bool resize_in_flush; + my_bool can_be_used; + size_t key_cache_mem_size; + uint key_cache_block_size; + ulong min_warm_blocks; + ulong age_threshold; + ulonglong keycache_time; + uint hash_entries; + int hash_links; + int hash_links_used; + int disk_blocks; + ulong blocks_used; + ulong blocks_unused; + ulong blocks_changed; + ulong warm_blocks; + ulong cnt_for_resize_op; + long blocks_available; + HASH_LINK **hash_root; + HASH_LINK *hash_link_root; + HASH_LINK *free_hash_list; + BLOCK_LINK *free_block_list; + BLOCK_LINK *block_root; + uchar *block_mem; + BLOCK_LINK *used_last; + BLOCK_LINK *used_ins; + pthread_mutex_t cache_lock; + KEYCACHE_WQUEUE resize_queue; + KEYCACHE_WQUEUE waiting_for_resize_cnt; + KEYCACHE_WQUEUE waiting_for_hash_link; + KEYCACHE_WQUEUE waiting_for_block; + BLOCK_LINK *changed_blocks[128]; + BLOCK_LINK *file_blocks[128]; + ulonglong param_buff_size; + ulong param_block_size; + ulong param_division_limit; + ulong param_age_threshold; + ulong global_blocks_changed; + ulonglong global_cache_w_requests; + ulonglong global_cache_write; + ulonglong global_cache_r_requests; + ulonglong global_cache_read; + int blocks; + my_bool in_init; +} KEY_CACHE; +extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache; +extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, + size_t use_mem, uint division_limit, + uint age_threshold); +extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, + size_t use_mem, uint division_limit, + uint age_threshold); +extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit, + uint age_threshold); +extern uchar *key_cache_read(KEY_CACHE *keycache, + File file, my_off_t filepos, int level, + uchar *buff, uint length, + uint block_length,int return_buffer); +extern int key_cache_insert(KEY_CACHE *keycache, + File file, my_off_t filepos, int level, + uchar *buff, uint length); +extern int key_cache_write(KEY_CACHE *keycache, + File file, my_off_t filepos, int level, + uchar *buff, uint length, + uint block_length,int force_write); +extern int flush_key_blocks(KEY_CACHE *keycache, + int file, enum flush_type type); +extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup); +extern my_bool multi_keycache_init(void); +extern void multi_keycache_free(void); +extern KEY_CACHE *multi_key_cache_search(uchar *key, uint length); +extern my_bool multi_key_cache_set(const uchar *key, uint length, + KEY_CACHE *key_cache); +extern void multi_key_cache_change(KEY_CACHE *old_data, + KEY_CACHE *new_data); +extern int reset_key_cache_counters(const char *name, + KEY_CACHE *key_cache); +enum legacy_db_type +{ + DB_TYPE_UNKNOWN=0,DB_TYPE_DIAB_ISAM=1, + DB_TYPE_HASH,DB_TYPE_MISAM,DB_TYPE_PISAM, + DB_TYPE_RMS_ISAM, DB_TYPE_HEAP, DB_TYPE_ISAM, + DB_TYPE_MRG_ISAM, DB_TYPE_MYISAM, DB_TYPE_MRG_MYISAM, + DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB, + DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER, + DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB, + DB_TYPE_FEDERATED_DB, + DB_TYPE_BLACKHOLE_DB, + DB_TYPE_PARTITION_DB, + DB_TYPE_BINLOG, + DB_TYPE_SOLID, + DB_TYPE_PBXT, + DB_TYPE_TABLE_FUNCTION, + DB_TYPE_MEMCACHE, + DB_TYPE_FALCON, + DB_TYPE_MARIA, + DB_TYPE_FIRST_DYNAMIC=42, + DB_TYPE_DEFAULT=127 +}; +enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED, + ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED, + ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT, ROW_TYPE_PAGE }; +enum enum_binlog_func { + BFN_RESET_LOGS= 1, + BFN_RESET_SLAVE= 2, + BFN_BINLOG_WAIT= 3, + BFN_BINLOG_END= 4, + BFN_BINLOG_PURGE_FILE= 5 +}; +enum enum_binlog_command { + LOGCOM_CREATE_TABLE, + LOGCOM_ALTER_TABLE, + LOGCOM_RENAME_TABLE, + LOGCOM_DROP_TABLE, + LOGCOM_CREATE_DB, + LOGCOM_ALTER_DB, + LOGCOM_DROP_DB +}; +typedef ulonglong my_xid; +struct xid_t { + long formatID; + long gtrid_length; + long bqual_length; + char data[128]; + xid_t() {} + In_C_you_should_use_my_bool_instead() eq(struct xid_t *xid) + { return eq(xid->gtrid_length, xid->bqual_length, xid->data); } + In_C_you_should_use_my_bool_instead() eq(long g, long b, const char *d) + { return g == gtrid_length && b == bqual_length && !memcmp(d, data, g+b); } + void set(struct xid_t *xid) + { memcpy(this, xid, xid->length()); } + void set(long f, const char *g, long gl, const char *b, long bl) + { + formatID= f; + memcpy(data, g, gtrid_length= gl); + memcpy(data+gl, b, bqual_length= bl); + } + void set(ulonglong xid) + { + my_xid tmp; + formatID= 1; + set(8, 0, "MySQLXid"); + memcpy(data+8, &server_id, sizeof(server_id)); + tmp= xid; + memcpy(data+(8 +sizeof(server_id)), &tmp, sizeof(tmp)); + gtrid_length=((8 +sizeof(server_id))+sizeof(my_xid)); + } + void set(long g, long b, const char *d) + { + formatID= 1; + gtrid_length= g; + bqual_length= b; + memcpy(data, d, g+b); + } + In_C_you_should_use_my_bool_instead() is_null() { return formatID == -1; } + void null() { formatID= -1; } + my_xid quick_get_my_xid() + { + my_xid tmp; + memcpy(&tmp, data+(8 +sizeof(server_id)), sizeof(tmp)); + return tmp; + } + my_xid get_my_xid() + { + return gtrid_length == ((8 +sizeof(server_id))+sizeof(my_xid)) && bqual_length == 0 && + !memcmp(data+8, &server_id, sizeof(server_id)) && + !memcmp(data, "MySQLXid", 8) ? + quick_get_my_xid() : 0; + } + uint length() + { + return sizeof(formatID)+sizeof(gtrid_length)+sizeof(bqual_length)+ + gtrid_length+bqual_length; + } + uchar *key() + { + return (uchar *)>rid_length; + } + uint key_length() + { + return sizeof(gtrid_length)+sizeof(bqual_length)+gtrid_length+bqual_length; + } +}; +typedef struct xid_t XID; +enum ts_command_type +{ + TS_CMD_NOT_DEFINED = -1, + CREATE_TABLESPACE = 0, + ALTER_TABLESPACE = 1, + CREATE_LOGFILE_GROUP = 2, + ALTER_LOGFILE_GROUP = 3, + DROP_TABLESPACE = 4, + DROP_LOGFILE_GROUP = 5, + CHANGE_FILE_TABLESPACE = 6, + ALTER_ACCESS_MODE_TABLESPACE = 7 +}; +enum ts_alter_tablespace_type +{ + TS_ALTER_TABLESPACE_TYPE_NOT_DEFINED = -1, + ALTER_TABLESPACE_ADD_FILE = 1, + ALTER_TABLESPACE_DROP_FILE = 2 +}; +enum tablespace_access_mode +{ + TS_NOT_DEFINED= -1, + TS_READ_ONLY = 0, + TS_READ_WRITE = 1, + TS_NOT_ACCESSIBLE = 2 +}; +struct handlerton; +class st_alter_tablespace : public Sql_alloc +{ + public: + const char *tablespace_name; + const char *logfile_group_name; + enum ts_command_type ts_cmd_type; + enum ts_alter_tablespace_type ts_alter_tablespace_type; + const char *data_file_name; + const char *undo_file_name; + const char *redo_file_name; + ulonglong extent_size; + ulonglong undo_buffer_size; + ulonglong redo_buffer_size; + ulonglong initial_size; + ulonglong autoextend_size; + ulonglong max_size; + uint nodegroup_id; + handlerton *storage_engine; + In_C_you_should_use_my_bool_instead() wait_until_completed; + const char *ts_comment; + enum tablespace_access_mode ts_access_mode; + st_alter_tablespace() + { + tablespace_name= NULL; + logfile_group_name= "DEFAULT_LG"; + ts_cmd_type= TS_CMD_NOT_DEFINED; + data_file_name= NULL; + undo_file_name= NULL; + redo_file_name= NULL; + extent_size= 1024*1024; + undo_buffer_size= 8*1024*1024; + redo_buffer_size= 8*1024*1024; + initial_size= 128*1024*1024; + autoextend_size= 0; + max_size= 0; + storage_engine= NULL; + nodegroup_id= 65535; + wait_until_completed= (1); + ts_comment= NULL; + ts_access_mode= TS_NOT_DEFINED; + } +}; +struct st_table; +typedef struct st_table TABLE; +typedef struct st_table_share TABLE_SHARE; +struct st_foreign_key_info; +typedef struct st_foreign_key_info FOREIGN_KEY_INFO; +typedef In_C_you_should_use_my_bool_instead() (stat_print_fn)(THD *thd, const char *type, uint type_len, + const char *file, uint file_len, + const char *status, uint status_len); +enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX }; +extern st_plugin_int *hton2plugin[15]; +enum log_status +{ + HA_LOG_STATUS_FREE= 0, + HA_LOG_STATUS_INUSE= 1, + HA_LOG_STATUS_NOSUCHLOG= 2 +}; +void signal_log_not_needed(struct handlerton, char *log_file); +struct handler_log_file_data { + LEX_STRING filename; + enum log_status status; +}; +enum handler_iterator_type +{ + HA_TRANSACTLOG_ITERATOR= 1 +}; +enum handler_create_iterator_result +{ + HA_ITERATOR_OK, + HA_ITERATOR_UNSUPPORTED, + HA_ITERATOR_ERROR +}; +struct handler_iterator { + int (*next)(struct handler_iterator *, void *iterator_object); + void (*destroy)(struct handler_iterator *); + void *buffer; +}; +struct handlerton +{ + SHOW_COMP_OPTION state; + enum legacy_db_type db_type; + uint slot; + uint savepoint_offset; + int (*close_connection)(handlerton *hton, THD *thd); + int (*savepoint_set)(handlerton *hton, THD *thd, void *sv); + int (*savepoint_rollback)(handlerton *hton, THD *thd, void *sv); + int (*savepoint_release)(handlerton *hton, THD *thd, void *sv); + int (*commit)(handlerton *hton, THD *thd, In_C_you_should_use_my_bool_instead() all); + int (*rollback)(handlerton *hton, THD *thd, In_C_you_should_use_my_bool_instead() all); + int (*prepare)(handlerton *hton, THD *thd, In_C_you_should_use_my_bool_instead() all); + int (*recover)(handlerton *hton, XID *xid_list, uint len); + int (*commit_by_xid)(handlerton *hton, XID *xid); + int (*rollback_by_xid)(handlerton *hton, XID *xid); + void *(*create_cursor_read_view)(handlerton *hton, THD *thd); + void (*set_cursor_read_view)(handlerton *hton, THD *thd, void *read_view); + void (*close_cursor_read_view)(handlerton *hton, THD *thd, void *read_view); + handler *(*create)(handlerton *hton, TABLE_SHARE *table, MEM_ROOT *mem_root); + void (*drop_database)(handlerton *hton, char* path); + int (*panic)(handlerton *hton, enum ha_panic_function flag); + int (*start_consistent_snapshot)(handlerton *hton, THD *thd); + In_C_you_should_use_my_bool_instead() (*flush_logs)(handlerton *hton); + In_C_you_should_use_my_bool_instead() (*show_status)(handlerton *hton, THD *thd, stat_print_fn *print, enum ha_stat_type stat); + uint (*partition_flags)(); + uint (*alter_table_flags)(uint flags); + int (*alter_tablespace)(handlerton *hton, THD *thd, st_alter_tablespace *ts_info); + int (*fill_files_table)(handlerton *hton, THD *thd, + TABLE_LIST *tables, + class Item *cond); + uint32 flags; + int (*binlog_func)(handlerton *hton, THD *thd, enum_binlog_func fn, void *arg); + void (*binlog_log_query)(handlerton *hton, THD *thd, + enum_binlog_command binlog_command, + const char *query, uint query_length, + const char *db, const char *table_name); + int (*release_temporary_latches)(handlerton *hton, THD *thd); + enum log_status (*get_log_status)(handlerton *hton, char *log); + enum handler_create_iterator_result + (*create_iterator)(handlerton *hton, enum handler_iterator_type type, + struct handler_iterator *fill_this_in); + int (*discover)(handlerton *hton, THD* thd, const char *db, + const char *name, + uchar **frmblob, + size_t *frmlen); + int (*find_files)(handlerton *hton, THD *thd, + const char *db, + const char *path, + const char *wild, In_C_you_should_use_my_bool_instead() dir, List<LEX_STRING> *files); + int (*table_exists_in_engine)(handlerton *hton, THD* thd, const char *db, + const char *name); + uint32 license; + void *data; +}; +class Ha_trx_info; +struct THD_TRANS +{ + In_C_you_should_use_my_bool_instead() no_2pc; + Ha_trx_info *ha_list; + In_C_you_should_use_my_bool_instead() modified_non_trans_table; + void reset() { no_2pc= (0); modified_non_trans_table= (0); } +}; +class Ha_trx_info +{ +public: + void register_ha(THD_TRANS *trans, handlerton *ht_arg) + { + assert(m_flags == 0); + assert(m_ht == NULL); + assert(m_next == NULL); + m_ht= ht_arg; + m_flags= (int) TRX_READ_ONLY; + m_next= trans->ha_list; + trans->ha_list= this; + } + void reset() + { + m_next= NULL; + m_ht= NULL; + m_flags= 0; + } + Ha_trx_info() { reset(); } + void set_trx_read_write() + { + assert(is_started()); + m_flags|= (int) TRX_READ_WRITE; + } + In_C_you_should_use_my_bool_instead() is_trx_read_write() const + { + assert(is_started()); + return m_flags & (int) TRX_READ_WRITE; + } + In_C_you_should_use_my_bool_instead() is_started() const { return m_ht != NULL; } + void coalesce_trx_with(const Ha_trx_info *stmt_trx) + { + assert(is_started()); + if (stmt_trx->is_trx_read_write()) + set_trx_read_write(); + } + Ha_trx_info *next() const + { + assert(is_started()); + return m_next; + } + handlerton *ht() const + { + assert(is_started()); + return m_ht; + } +private: + enum { TRX_READ_ONLY= 0, TRX_READ_WRITE= 1 }; + Ha_trx_info *m_next; + handlerton *m_ht; + uchar m_flags; +}; +enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED, + ISO_REPEATABLE_READ, ISO_SERIALIZABLE}; +enum ndb_distribution { ND_KEYHASH= 0, ND_LINHASH= 1 }; +typedef struct { + ulonglong data_file_length; + ulonglong max_data_file_length; + ulonglong index_file_length; + ulonglong delete_length; + ha_rows records; + ulong mean_rec_length; + time_t create_time; + time_t check_time; + time_t update_time; + ulonglong check_sum; +} PARTITION_INFO; +class Item; +struct st_table_log_memory_entry; +class partition_info; +struct st_partition_iter; +enum ha_choice { HA_CHOICE_UNDEF, HA_CHOICE_NO, HA_CHOICE_YES }; +typedef struct st_ha_create_information +{ + CHARSET_INFO *table_charset, *default_table_charset; + LEX_STRING connect_string; + const char *password, *tablespace; + LEX_STRING comment; + const char *data_file_name, *index_file_name; + const char *alias; + ulonglong max_rows,min_rows; + ulonglong auto_increment_value; + ulong table_options; + ulong avg_row_length; + ulong used_fields; + ulong key_block_size; + SQL_LIST merge_list; + handlerton *db_type; + enum row_type row_type; + uint null_bits; + uint options; + uint merge_insert_method; + uint extra_size; + enum ha_choice transactional; + In_C_you_should_use_my_bool_instead() table_existed; + In_C_you_should_use_my_bool_instead() frm_only; + In_C_you_should_use_my_bool_instead() varchar; + enum ha_storage_media storage_media; + enum ha_choice page_checksum; +} HA_CREATE_INFO; +typedef struct st_key_create_information +{ + enum ha_key_alg algorithm; + ulong block_size; + LEX_STRING parser_name; +} KEY_CREATE_INFO; +class TABLEOP_HOOKS +{ +public: + TABLEOP_HOOKS() {} + virtual ~TABLEOP_HOOKS() {} + inline void prelock(TABLE **tables, uint count) + { + do_prelock(tables, count); + } + inline int postlock(TABLE **tables, uint count) + { + return do_postlock(tables, count); + } +private: + virtual void do_prelock(TABLE **tables, uint count) + { + } + virtual int do_postlock(TABLE **tables, uint count) + { + return 0; + } +}; +typedef struct st_savepoint SAVEPOINT; +extern ulong savepoint_alloc_size; +extern KEY_CREATE_INFO default_key_create_info; +typedef class Item COND; +typedef struct st_ha_check_opt +{ + st_ha_check_opt() {} + ulong sort_buffer_size; + uint flags; + uint sql_flags; + KEY_CACHE *key_cache; + void init(); +} HA_CHECK_OPT; +typedef struct st_handler_buffer +{ + const uchar *buffer; + const uchar *buffer_end; + uchar *end_of_used_area; +} HANDLER_BUFFER; +typedef struct system_status_var SSV; +class ha_statistics +{ +public: + ulonglong data_file_length; + ulonglong max_data_file_length; + ulonglong index_file_length; + ulonglong max_index_file_length; + ulonglong delete_length; + ulonglong auto_increment_value; + ha_rows records; + ha_rows deleted; + ulong mean_rec_length; + time_t create_time; + time_t check_time; + time_t update_time; + uint block_size; + ha_statistics(): + data_file_length(0), max_data_file_length(0), + index_file_length(0), delete_length(0), auto_increment_value(0), + records(0), deleted(0), mean_rec_length(0), create_time(0), + check_time(0), update_time(0), block_size(0) + {} +}; +uint calculate_key_len(TABLE *, uint, const uchar *, key_part_map); +class handler :public Sql_alloc +{ +public: + typedef ulonglong Table_flags; +protected: + struct st_table_share *table_share; + struct st_table *table; + Table_flags cached_table_flags; + ha_rows estimation_rows_to_insert; +public: + handlerton *ht; + uchar *ref; + uchar *dup_ref; + ha_statistics stats; + In_C_you_should_use_my_bool_instead() multi_range_sorted; + KEY_MULTI_RANGE *multi_range_curr; + KEY_MULTI_RANGE *multi_range_end; + HANDLER_BUFFER *multi_range_buffer; + key_range save_end_range, *end_range; + KEY_PART_INFO *range_key_part; + int key_compare_result_on_equal; + In_C_you_should_use_my_bool_instead() eq_range; + uint errkey; + uint key_used_on_scan; + uint active_index; + uint ref_length; + FT_INFO *ft_handler; + enum {NONE=0, INDEX, RND} inited; + In_C_you_should_use_my_bool_instead() locked; + In_C_you_should_use_my_bool_instead() implicit_emptied; + const COND *pushed_cond; + ulonglong next_insert_id; + ulonglong insert_id_for_cur_row; + Discrete_interval auto_inc_interval_for_cur_row; + handler(handlerton *ht_arg, TABLE_SHARE *share_arg) + :table_share(share_arg), table(0), + estimation_rows_to_insert(0), ht(ht_arg), + ref(0), key_used_on_scan(64), active_index(64), + ref_length(sizeof(my_off_t)), + ft_handler(0), inited(NONE), + locked((0)), implicit_emptied(0), + pushed_cond(0), next_insert_id(0), insert_id_for_cur_row(0) + {} + virtual ~handler(void) + { + assert(locked == (0)); + } + virtual handler *clone(MEM_ROOT *mem_root); + void init() + { + cached_table_flags= table_flags(); + } + int ha_open(TABLE *table, const char *name, int mode, int test_if_locked); + int ha_index_init(uint idx, In_C_you_should_use_my_bool_instead() sorted) + { + int result; + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("ha_index_init","./sql/handler.h",1159,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + assert(inited==NONE); + if (!(result= index_init(idx, sorted))) + inited=INDEX; + do {_db_return_ (1163, &_db_func_, &_db_file_, &_db_level_); return(result);} while(0); + } + int ha_index_end() + { + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("ha_index_end","./sql/handler.h",1167,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + assert(inited==INDEX); + inited=NONE; + do {_db_return_ (1170, &_db_func_, &_db_file_, &_db_level_); return(index_end());} while(0); + } + int ha_rnd_init(In_C_you_should_use_my_bool_instead() scan) + { + int result; + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("ha_rnd_init","./sql/handler.h",1175,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + assert(inited==NONE || (inited==RND && scan)); + inited= (result= rnd_init(scan)) ? NONE: RND; + do {_db_return_ (1178, &_db_func_, &_db_file_, &_db_level_); return(result);} while(0); + } + int ha_rnd_end() + { + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("ha_rnd_end","./sql/handler.h",1182,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + assert(inited==RND); + inited=NONE; + do {_db_return_ (1185, &_db_func_, &_db_file_, &_db_level_); return(rnd_end());} while(0); + } + int ha_reset(); + int ha_index_or_rnd_end() + { + return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0; + } + Table_flags ha_table_flags() const { return cached_table_flags; } + int ha_external_lock(THD *thd, int lock_type); + int ha_write_row(uchar * buf); + int ha_update_row(const uchar * old_data, uchar * new_data); + int ha_delete_row(const uchar * buf); + void ha_release_auto_increment(); + int ha_check_for_upgrade(HA_CHECK_OPT *check_opt); + int ha_check(THD *thd, HA_CHECK_OPT *check_opt); + int ha_repair(THD* thd, HA_CHECK_OPT* check_opt); + void ha_start_bulk_insert(ha_rows rows) + { + estimation_rows_to_insert= rows; + start_bulk_insert(rows); + } + int ha_end_bulk_insert() + { + estimation_rows_to_insert= 0; + return end_bulk_insert(); + } + int ha_bulk_update_row(const uchar *old_data, uchar *new_data, + uint *dup_key_found); + int ha_delete_all_rows(); + int ha_reset_auto_increment(ulonglong value); + int ha_backup(THD* thd, HA_CHECK_OPT* check_opt); + int ha_restore(THD* thd, HA_CHECK_OPT* check_opt); + int ha_optimize(THD* thd, HA_CHECK_OPT* check_opt); + int ha_analyze(THD* thd, HA_CHECK_OPT* check_opt); + In_C_you_should_use_my_bool_instead() ha_check_and_repair(THD *thd); + int ha_disable_indexes(uint mode); + int ha_enable_indexes(uint mode); + int ha_discard_or_import_tablespace(my_bool discard); + void ha_prepare_for_alter(); + int ha_rename_table(const char *from, const char *to); + int ha_delete_table(const char *name); + void ha_drop_table(const char *name); + int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info); + int ha_create_handler_files(const char *name, const char *old_name, + int action_flag, HA_CREATE_INFO *info); + int ha_change_partitions(HA_CREATE_INFO *create_info, + const char *path, + ulonglong *copied, + ulonglong *deleted, + const uchar *pack_frm_data, + size_t pack_frm_len); + int ha_drop_partitions(const char *path); + int ha_rename_partitions(const char *path); + int ha_optimize_partitions(THD *thd); + int ha_analyze_partitions(THD *thd); + int ha_check_partitions(THD *thd); + int ha_repair_partitions(THD *thd); + void adjust_next_insert_id_after_explicit_value(ulonglong nr); + int update_auto_increment(); + void print_keydup_error(uint key_nr, const char *msg); + virtual void print_error(int error, myf errflag); + virtual In_C_you_should_use_my_bool_instead() get_error_message(int error, String *buf); + uint get_dup_key(int error); + virtual void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share) + { + table= table_arg; + table_share= share; + } + virtual double scan_time() + { return ((double) (ulonglong) (stats.data_file_length)) / 4096 + 2; } + virtual double read_time(uint index, uint ranges, ha_rows rows) + { return ((double) (ulonglong) (ranges+rows)); } + virtual const key_map *keys_to_use_for_scanning() { return &key_map_empty; } + In_C_you_should_use_my_bool_instead() has_transactions() + { return (ha_table_flags() & (1 << 0)) == 0; } + virtual uint extra_rec_buf_length() const { return 0; } + virtual In_C_you_should_use_my_bool_instead() is_fatal_error(int error, uint flags) + { + if (!error || + ((flags & 1) && + (error == 121 || + error == 141))) + return (0); + return (1); + } + virtual ha_rows records() { return stats.records; } + virtual ha_rows estimate_rows_upper_bound() + { return stats.records+10; } + virtual enum row_type get_row_type() const { return ROW_TYPE_NOT_USED; } + virtual const char *index_type(uint key_number) { assert(0); return "";} + virtual void column_bitmaps_signal(); + uint get_index(void) const { return active_index; } + virtual int close(void)=0; + virtual In_C_you_should_use_my_bool_instead() start_bulk_update() { return 1; } + virtual In_C_you_should_use_my_bool_instead() start_bulk_delete() { return 1; } + virtual int exec_bulk_update(uint *dup_key_found) + { + assert((0)); + return 131; + } + virtual void end_bulk_update() { return; } + virtual int end_bulk_delete() + { + assert((0)); + return 131; + } + virtual int index_read_map(uchar * buf, const uchar * key, + key_part_map keypart_map, + enum ha_rkey_function find_flag) + { + uint key_len= calculate_key_len(table, active_index, key, keypart_map); + return index_read(buf, key, key_len, find_flag); + } + virtual int index_read_idx_map(uchar * buf, uint index, const uchar * key, + key_part_map keypart_map, + enum ha_rkey_function find_flag); + virtual int index_next(uchar * buf) + { return 131; } + virtual int index_prev(uchar * buf) + { return 131; } + virtual int index_first(uchar * buf) + { return 131; } + virtual int index_last(uchar * buf) + { return 131; } + virtual int index_next_same(uchar *buf, const uchar *key, uint keylen); + virtual int index_read_last_map(uchar * buf, const uchar * key, + key_part_map keypart_map) + { + uint key_len= calculate_key_len(table, active_index, key, keypart_map); + return index_read_last(buf, key, key_len); + } + virtual int read_multi_range_first(KEY_MULTI_RANGE **found_range_p, + KEY_MULTI_RANGE *ranges, uint range_count, + In_C_you_should_use_my_bool_instead() sorted, HANDLER_BUFFER *buffer); + virtual int read_multi_range_next(KEY_MULTI_RANGE **found_range_p); + virtual int read_range_first(const key_range *start_key, + const key_range *end_key, + In_C_you_should_use_my_bool_instead() eq_range, In_C_you_should_use_my_bool_instead() sorted); + virtual int read_range_next(); + int compare_key(key_range *range); + virtual int ft_init() { return 131; } + void ft_end() { ft_handler=NULL; } + virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key) + { return NULL; } + virtual int ft_read(uchar *buf) { return 131; } + virtual int rnd_next(uchar *buf)=0; + virtual int rnd_pos(uchar * buf, uchar *pos)=0; + virtual int rnd_pos_by_record(uchar *record) + { + position(record); + return rnd_pos(record, ref); + } + virtual int read_first_row(uchar *buf, uint primary_key); + virtual int restart_rnd_next(uchar *buf, uchar *pos) + { return 131; } + virtual int rnd_same(uchar *buf, uint inx) + { return 131; } + virtual ha_rows records_in_range(uint inx, key_range *min_key, key_range *max_key) + { return (ha_rows) 10; } + virtual void position(const uchar *record)=0; + virtual int info(uint)=0; + virtual void get_dynamic_partition_info(PARTITION_INFO *stat_info, + uint part_id); + virtual int extra(enum ha_extra_function operation) + { return 0; } + virtual int extra_opt(enum ha_extra_function operation, ulong cache_size) + { return extra(operation); } + virtual In_C_you_should_use_my_bool_instead() was_semi_consistent_read() { return 0; } + virtual void try_semi_consistent_read(In_C_you_should_use_my_bool_instead()) {} + virtual void unlock_row() {} + virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;} + virtual void get_auto_increment(ulonglong offset, ulonglong increment, + ulonglong nb_desired_values, + ulonglong *first_value, + ulonglong *nb_reserved_values); + void set_next_insert_id(ulonglong id) + { + do {_db_pargs_(1488,"info"); _db_doprnt_ ("auto_increment: next value %lu", (ulong)id);} while(0); + next_insert_id= id; + } + void restore_auto_increment(ulonglong prev_insert_id) + { + next_insert_id= (prev_insert_id > 0) ? prev_insert_id : + insert_id_for_cur_row; + } + virtual void update_create_info(HA_CREATE_INFO *create_info) {} + int check_old_types(); + virtual int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual int preload_keys(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual int dump(THD* thd, int fd = -1) { return 131; } + virtual int indexes_are_disabled(void) {return 0;} + virtual int net_read_dump(NET* net) { return 131; } + virtual char *update_table_comment(const char * comment) + { return (char*) comment;} + virtual void append_create_info(String *packet) {} + virtual In_C_you_should_use_my_bool_instead() is_fk_defined_on_table_or_index(uint index) + { return (0); } + virtual char* get_foreign_key_create_info() + { return(NULL);} + virtual char* get_tablespace_name(THD *thd, char *name, uint name_len) + { return(NULL);} + virtual In_C_you_should_use_my_bool_instead() can_switch_engines() { return 1; } + virtual int get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list) + { return 0; } + virtual uint referenced_by_foreign_key() { return 0;} + virtual void init_table_handle_for_HANDLER() + { return; } + virtual void free_foreign_key_create_info(char* str) {} + virtual const char *table_type() const =0; + virtual const char **bas_ext() const =0; + virtual int get_default_no_partitions(HA_CREATE_INFO *info) { return 1;} + virtual void set_auto_partitions(partition_info *part_info) { return; } + virtual In_C_you_should_use_my_bool_instead() get_no_parts(const char *name, + uint *no_parts) + { + *no_parts= 0; + return 0; + } + virtual void set_part_info(partition_info *part_info) {return;} + virtual ulong index_flags(uint idx, uint part, In_C_you_should_use_my_bool_instead() all_parts) const =0; + virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys) + { return (131); } + virtual int prepare_drop_index(TABLE *table_arg, uint *key_num, + uint num_of_keys) + { return (131); } + virtual int final_drop_index(TABLE *table_arg) + { return (131); } + uint max_record_length() const + { return ((65535) < (max_supported_record_length()) ? (65535) : (max_supported_record_length())); } + uint max_keys() const + { return ((64) < (max_supported_keys()) ? (64) : (max_supported_keys())); } + uint max_key_parts() const + { return ((16) < (max_supported_key_parts()) ? (16) : (max_supported_key_parts())); } + uint max_key_length() const + { return ((3072) < (max_supported_key_length()) ? (3072) : (max_supported_key_length())); } + uint max_key_part_length() const + { return ((3072) < (max_supported_key_part_length()) ? (3072) : (max_supported_key_part_length())); } + virtual uint max_supported_record_length() const { return 65535; } + virtual uint max_supported_keys() const { return 0; } + virtual uint max_supported_key_parts() const { return 16; } + virtual uint max_supported_key_length() const { return 3072; } + virtual uint max_supported_key_part_length() const { return 255; } + virtual uint min_record_length(uint options) const { return 1; } + virtual In_C_you_should_use_my_bool_instead() low_byte_first() const { return 1; } + virtual uint checksum() const { return 0; } + virtual In_C_you_should_use_my_bool_instead() is_crashed() const { return 0; } + virtual In_C_you_should_use_my_bool_instead() auto_repair() const { return 0; } + virtual uint lock_count(void) const { return 1; } + virtual THR_LOCK_DATA **store_lock(THD *thd, + THR_LOCK_DATA **to, + enum thr_lock_type lock_type)=0; + virtual uint8 table_cache_type() { return 0; } + virtual my_bool register_query_cache_table(THD *thd, char *table_key, + uint key_length, + qc_engine_callback + *engine_callback, + ulonglong *engine_data) + { + *engine_callback= 0; + return (1); + } + virtual In_C_you_should_use_my_bool_instead() primary_key_is_clustered() { return (0); } + virtual int cmp_ref(const uchar *ref1, const uchar *ref2) + { + return memcmp(ref1, ref2, ref_length); + } + virtual const COND *cond_push(const COND *cond) { return cond; }; + virtual void cond_pop() { return; }; + virtual In_C_you_should_use_my_bool_instead() check_if_incompatible_data(HA_CREATE_INFO *create_info, + uint table_changes) + { return 1; } + virtual void use_hidden_primary_key(); +protected: + void ha_statistic_increment(ulong SSV::*offset) const; + void **ha_data(THD *) const; + THD *ha_thd(void) const; + virtual int rename_table(const char *from, const char *to); + virtual int delete_table(const char *name); +private: + inline void mark_trx_read_write(); +private: + virtual int open(const char *name, int mode, uint test_if_locked)=0; + virtual int index_init(uint idx, In_C_you_should_use_my_bool_instead() sorted) { active_index= idx; return 0; } + virtual int index_end() { active_index= 64; return 0; } + virtual int rnd_init(In_C_you_should_use_my_bool_instead() scan)= 0; + virtual int rnd_end() { return 0; } + virtual int write_row(uchar *buf __attribute__((unused))) + { + return 131; + } + virtual int update_row(const uchar *old_data __attribute__((unused)), + uchar *new_data __attribute__((unused))) + { + return 131; + } + virtual int delete_row(const uchar *buf __attribute__((unused))) + { + return 131; + } + virtual int reset() { return 0; } + virtual Table_flags table_flags(void) const= 0; + virtual int external_lock(THD *thd __attribute__((unused)), + int lock_type __attribute__((unused))) + { + return 0; + } + virtual void release_auto_increment() { return; }; + virtual int check_for_upgrade(HA_CHECK_OPT *check_opt) + { return 0; } + virtual int check(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual int repair(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual void start_bulk_insert(ha_rows rows) {} + virtual int end_bulk_insert() { return 0; } + virtual int index_read(uchar * buf, const uchar * key, uint key_len, + enum ha_rkey_function find_flag) + { return 131; } + virtual int index_read_last(uchar * buf, const uchar * key, uint key_len) + { return ((_my_thread_var())->thr_errno= 131); } + virtual int bulk_update_row(const uchar *old_data, uchar *new_data, + uint *dup_key_found) + { + assert((0)); + return 131; + } + virtual int delete_all_rows() + { return ((_my_thread_var())->thr_errno=131); } + virtual int reset_auto_increment(ulonglong value) + { return 131; } + virtual int backup(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual int restore(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual int optimize(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt) + { return -1; } + virtual In_C_you_should_use_my_bool_instead() check_and_repair(THD *thd) { return (1); } + virtual int disable_indexes(uint mode) { return 131; } + virtual int enable_indexes(uint mode) { return 131; } + virtual int discard_or_import_tablespace(my_bool discard) + { return ((_my_thread_var())->thr_errno=131); } + virtual void prepare_for_alter() { return; } + virtual void drop_table(const char *name); + virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0; + virtual int create_handler_files(const char *name, const char *old_name, + int action_flag, HA_CREATE_INFO *info) + { return (0); } + virtual int change_partitions(HA_CREATE_INFO *create_info, + const char *path, + ulonglong *copied, + ulonglong *deleted, + const uchar *pack_frm_data, + size_t pack_frm_len) + { return 131; } + virtual int drop_partitions(const char *path) + { return 131; } + virtual int rename_partitions(const char *path) + { return 131; } + virtual int optimize_partitions(THD *thd) + { return 131; } + virtual int analyze_partitions(THD *thd) + { return 131; } + virtual int check_partitions(THD *thd) + { return 131; } + virtual int repair_partitions(THD *thd) + { return 131; } +}; +extern const char *ha_row_type[]; +extern const char *tx_isolation_names[]; +extern const char *binlog_format_names[]; +extern TYPELIB tx_isolation_typelib; +extern TYPELIB myisam_stats_method_typelib; +extern ulong total_ha, total_ha_2pc; +handlerton *ha_default_handlerton(THD *thd); +plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name); +plugin_ref ha_lock_engine(THD *thd, handlerton *hton); +handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type); +handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc, + handlerton *db_type); +handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type, + In_C_you_should_use_my_bool_instead() no_substitute, In_C_you_should_use_my_bool_instead() report_error); +static inline enum legacy_db_type ha_legacy_type(const handlerton *db_type) +{ + return (db_type == NULL) ? DB_TYPE_UNKNOWN : db_type->db_type; +} +static inline const char *ha_resolve_storage_engine_name(const handlerton *db_type) +{ + return db_type == NULL ? "UNKNOWN" : hton2plugin[db_type->slot]->name.str; +} +static inline In_C_you_should_use_my_bool_instead() ha_check_storage_engine_flag(const handlerton *db_type, uint32 flag) +{ + return db_type == NULL ? (0) : ((db_type->flags & flag) ? 1 : 0); +} +static inline In_C_you_should_use_my_bool_instead() ha_storage_engine_is_enabled(const handlerton *db_type) +{ + return (db_type && db_type->create) ? + (db_type->state == SHOW_OPTION_YES) : (0); +} +int ha_init_errors(void); +int ha_init(void); +int ha_end(void); +int ha_initialize_handlerton(st_plugin_int *plugin); +int ha_finalize_handlerton(st_plugin_int *plugin); +TYPELIB *ha_known_exts(void); +int ha_panic(enum ha_panic_function flag); +void ha_close_connection(THD* thd); +In_C_you_should_use_my_bool_instead() ha_flush_logs(handlerton *db_type); +void ha_drop_database(char* path); +int ha_create_table(THD *thd, const char *path, + const char *db, const char *table_name, + HA_CREATE_INFO *create_info, + In_C_you_should_use_my_bool_instead() update_create_info); +int ha_delete_table(THD *thd, handlerton *db_type, const char *path, + const char *db, const char *alias, In_C_you_should_use_my_bool_instead() generate_warning); +In_C_you_should_use_my_bool_instead() ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat); +int ha_create_table_from_engine(THD* thd, const char *db, const char *name); +int ha_discover(THD* thd, const char* dbname, const char* name, + uchar** frmblob, size_t* frmlen); +int ha_find_files(THD *thd,const char *db,const char *path, + const char *wild, In_C_you_should_use_my_bool_instead() dir, List<LEX_STRING>* files); +int ha_table_exists_in_engine(THD* thd, const char* db, const char* name); +extern "C" int ha_init_key_cache(const char *name, KEY_CACHE *key_cache); +int ha_resize_key_cache(KEY_CACHE *key_cache); +int ha_change_key_cache_param(KEY_CACHE *key_cache); +int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache); +int ha_end_key_cache(KEY_CACHE *key_cache); +int ha_release_temporary_latches(THD *thd); +int ha_start_consistent_snapshot(THD *thd); +int ha_commit_or_rollback_by_xid(XID *xid, In_C_you_should_use_my_bool_instead() commit); +int ha_commit_one_phase(THD *thd, In_C_you_should_use_my_bool_instead() all); +int ha_rollback_trans(THD *thd, In_C_you_should_use_my_bool_instead() all); +int ha_prepare(THD *thd); +int ha_recover(HASH *commit_list); +int ha_commit_trans(THD *thd, In_C_you_should_use_my_bool_instead() all); +int ha_autocommit_or_rollback(THD *thd, int error); +int ha_enable_transaction(THD *thd, In_C_you_should_use_my_bool_instead() on); +int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv); +int ha_savepoint(THD *thd, SAVEPOINT *sv); +int ha_release_savepoint(THD *thd, SAVEPOINT *sv); +void trans_register_ha(THD *thd, In_C_you_should_use_my_bool_instead() all, handlerton *ht); +#include "parse_file.h" +enum file_opt_type { + FILE_OPTIONS_STRING, + FILE_OPTIONS_ESTRING, + FILE_OPTIONS_ULONGLONG, + FILE_OPTIONS_REV, + FILE_OPTIONS_TIMESTAMP, + FILE_OPTIONS_STRLIST, + FILE_OPTIONS_ULLLIST +}; +struct File_option +{ + LEX_STRING name; + int offset; + file_opt_type type; +}; +class Unknown_key_hook +{ +public: + Unknown_key_hook() {} + virtual ~Unknown_key_hook() {} + virtual In_C_you_should_use_my_bool_instead() process_unknown_string(char *&unknown_key, uchar* base, + MEM_ROOT *mem_root, char *end)= 0; +}; +class File_parser_dummy_hook: public Unknown_key_hook +{ +public: + File_parser_dummy_hook() {} + virtual In_C_you_should_use_my_bool_instead() process_unknown_string(char *&unknown_key, uchar* base, + MEM_ROOT *mem_root, char *end); +}; +extern File_parser_dummy_hook file_parser_dummy_hook; +In_C_you_should_use_my_bool_instead() get_file_options_ulllist(char *&ptr, char *end, char *line, + uchar* base, File_option *parameter, + MEM_ROOT *mem_root); +char * +parse_escaped_string(char *ptr, char *end, MEM_ROOT *mem_root, LEX_STRING *str); +class File_parser; +File_parser *sql_parse_prepare(const LEX_STRING *file_name, + MEM_ROOT *mem_root, In_C_you_should_use_my_bool_instead() bad_format_errors); +my_bool +sql_create_definition_file(const LEX_STRING *dir, const LEX_STRING *file_name, + const LEX_STRING *type, + uchar* base, File_option *parameters, uint versions); +my_bool rename_in_schema_file(const char *schema, const char *old_name, + const char *new_name, ulonglong revision, + uint num_view_backups); +class File_parser: public Sql_alloc +{ + char *buff, *start, *end; + LEX_STRING file_type; + my_bool content_ok; +public: + File_parser() :buff(0), start(0), end(0), content_ok(0) + { file_type.str= 0; file_type.length= 0; } + my_bool ok() { return content_ok; } + LEX_STRING *type() { return &file_type; } + my_bool parse(uchar* base, MEM_ROOT *mem_root, + struct File_option *parameters, uint required, + Unknown_key_hook *hook); + friend File_parser *sql_parse_prepare(const LEX_STRING *file_name, + MEM_ROOT *mem_root, + In_C_you_should_use_my_bool_instead() bad_format_errors); +}; +#include "table.h" +class Item; +class Item_subselect; +class GRANT_TABLE; +class st_select_lex_unit; +class st_select_lex; +class partition_info; +class COND_EQUAL; +class Security_context; +class View_creation_ctx : public Default_object_creation_ctx, + public Sql_alloc +{ +public: + static View_creation_ctx *create(THD *thd); + static View_creation_ctx *create(THD *thd, + TABLE_LIST *view); +private: + View_creation_ctx(THD *thd) + : Default_object_creation_ctx(thd) + { } +}; +typedef struct st_order { + struct st_order *next; + Item **item; + Item *item_ptr; + Item **item_copy; + int counter; + In_C_you_should_use_my_bool_instead() asc; + In_C_you_should_use_my_bool_instead() free_me; + In_C_you_should_use_my_bool_instead() in_field_list; + In_C_you_should_use_my_bool_instead() counter_used; + Field *field; + char *buff; + table_map used, depend_map; +} ORDER; +typedef struct st_grant_info +{ + GRANT_TABLE *grant_table; + uint version; + ulong privilege; + ulong want_privilege; + ulong orig_want_privilege; +} GRANT_INFO; +enum tmp_table_type +{ + NO_TMP_TABLE, NON_TRANSACTIONAL_TMP_TABLE, TRANSACTIONAL_TMP_TABLE, + INTERNAL_TMP_TABLE, SYSTEM_TMP_TABLE +}; +enum trg_event_type +{ + TRG_EVENT_INSERT= 0, + TRG_EVENT_UPDATE= 1, + TRG_EVENT_DELETE= 2, + TRG_EVENT_MAX +}; +enum frm_type_enum +{ + FRMTYPE_ERROR= 0, + FRMTYPE_TABLE, + FRMTYPE_VIEW +}; +enum release_type { RELEASE_NORMAL, RELEASE_WAIT_FOR_DROP }; +typedef struct st_filesort_info +{ + IO_CACHE *io_cache; + uchar **sort_keys; + uchar *buffpek; + uint buffpek_len; + uchar *addon_buf; + size_t addon_length; + struct st_sort_addon_field *addon_field; + void (*unpack)(struct st_sort_addon_field *, uchar *); + uchar *record_pointers; + ha_rows found_records; +} FILESORT_INFO; +enum timestamp_auto_set_type +{ + TIMESTAMP_NO_AUTO_SET= 0, TIMESTAMP_AUTO_SET_ON_INSERT= 1, + TIMESTAMP_AUTO_SET_ON_UPDATE= 2, TIMESTAMP_AUTO_SET_ON_BOTH= 3 +}; +class Field_timestamp; +class Field_blob; +class Table_triggers_list; +enum enum_table_category +{ + TABLE_UNKNOWN_CATEGORY=0, + TABLE_CATEGORY_TEMPORARY=1, + TABLE_CATEGORY_USER=2, + TABLE_CATEGORY_SYSTEM=3, + TABLE_CATEGORY_INFORMATION=4, + TABLE_CATEGORY_PERFORMANCE=5 +}; +typedef enum enum_table_category TABLE_CATEGORY; +TABLE_CATEGORY get_table_category(const LEX_STRING *db, + const LEX_STRING *name); +typedef struct st_table_share +{ + st_table_share() {} + TABLE_CATEGORY table_category; + HASH name_hash; + MEM_ROOT mem_root; + TYPELIB keynames; + TYPELIB fieldnames; + TYPELIB *intervals; + pthread_mutex_t mutex; + pthread_cond_t cond; + struct st_table_share *next, + **prev; + Field **field; + Field **found_next_number_field; + Field *timestamp_field; + KEY *key_info; + uint *blob_field; + uchar *default_values; + LEX_STRING comment; + CHARSET_INFO *table_charset; + MY_BITMAP all_set; + LEX_STRING table_cache_key; + LEX_STRING db; + LEX_STRING table_name; + LEX_STRING path; + LEX_STRING normalized_path; + LEX_STRING connect_string; + key_map keys_in_use; + key_map keys_for_keyread; + ha_rows min_rows, max_rows; + ulong avg_row_length; + ulong raid_chunksize; + ulong version, mysql_version; + ulong timestamp_offset; + ulong reclength; + plugin_ref db_plugin; + inline handlerton *db_type() const + { + return db_plugin ? ((handlerton*)((db_plugin)[0]->data)) : NULL; + } + enum row_type row_type; + enum tmp_table_type tmp_table; + enum ha_choice transactional; + enum ha_choice page_checksum; + uint ref_count; + uint open_count; + uint blob_ptr_size; + uint key_block_size; + uint null_bytes, last_null_bit_pos; + uint fields; + uint rec_buff_length; + uint keys, key_parts; + uint max_key_length, max_unique_length, total_key_length; + uint uniques; + uint null_fields; + uint blob_fields; + uint timestamp_field_offset; + uint varchar_fields; + uint db_create_options; + uint db_options_in_use; + uint db_record_offset; + uint raid_type, raid_chunks; + uint rowid_field_offset; + uint primary_key; + uint next_number_index; + uint next_number_key_offset; + uint next_number_keypart; + uint error, open_errno, errarg; + uint column_bitmap_size; + uchar frm_version; + In_C_you_should_use_my_bool_instead() null_field_first; + In_C_you_should_use_my_bool_instead() system; + In_C_you_should_use_my_bool_instead() crypted; + In_C_you_should_use_my_bool_instead() db_low_byte_first; + In_C_you_should_use_my_bool_instead() crashed; + In_C_you_should_use_my_bool_instead() is_view; + In_C_you_should_use_my_bool_instead() name_lock, replace_with_name_lock; + In_C_you_should_use_my_bool_instead() waiting_on_cond; + ulong table_map_id; + ulonglong table_map_version; + int cached_row_logging_check; + void set_table_cache_key(char *key_buff, uint key_length) + { + table_cache_key.str= key_buff; + table_cache_key.length= key_length; + db.str= table_cache_key.str; + db.length= strlen(db.str); + table_name.str= db.str + db.length + 1; + table_name.length= strlen(table_name.str); + } + void set_table_cache_key(char *key_buff, const char *key, uint key_length) + { + memcpy(key_buff, key, key_length); + set_table_cache_key(key_buff, key_length); + } + inline In_C_you_should_use_my_bool_instead() honor_global_locks() + { + return ((table_category == TABLE_CATEGORY_USER) + || (table_category == TABLE_CATEGORY_SYSTEM)); + } + inline In_C_you_should_use_my_bool_instead() require_write_privileges() + { + return (table_category == TABLE_CATEGORY_PERFORMANCE); + } + inline ulong get_table_def_version() + { + return table_map_id; + } + enum enum_table_ref_type get_table_ref_type() const + { + if (is_view) + return TABLE_REF_VIEW; + switch (tmp_table) { + case NO_TMP_TABLE: + return TABLE_REF_BASE_TABLE; + case SYSTEM_TMP_TABLE: + return TABLE_REF_I_S_TABLE; + default: + return TABLE_REF_TMP_TABLE; + } + } + ulong get_table_ref_version() const + { + return (tmp_table == SYSTEM_TMP_TABLE || is_view) ? 0 : table_map_id; + } +} TABLE_SHARE; +extern ulong refresh_version; +enum index_hint_type +{ + INDEX_HINT_IGNORE, + INDEX_HINT_USE, + INDEX_HINT_FORCE +}; +struct st_table { + st_table() {} + TABLE_SHARE *s; + handler *file; + struct st_table *next, *prev; + struct st_table *parent; + TABLE_LIST *child_l; + TABLE_LIST **child_last_l; + THD *in_use; + Field **field; + uchar *record[2]; + uchar *write_row_record; + uchar *insert_values; + key_map covering_keys; + key_map quick_keys, merge_keys; + key_map keys_in_use_for_query; + key_map keys_in_use_for_group_by; + key_map keys_in_use_for_order_by; + KEY *key_info; + Field *next_number_field; + Field *found_next_number_field; + Field_timestamp *timestamp_field; + Table_triggers_list *triggers; + TABLE_LIST *pos_in_table_list; + ORDER *group; + const char *alias; + uchar *null_flags; + my_bitmap_map *bitmap_init_value; + MY_BITMAP def_read_set, def_write_set, tmp_set; + MY_BITMAP *read_set, *write_set; + query_id_t query_id; + ha_rows quick_rows[64]; + key_part_map const_key_parts[64]; + uint quick_key_parts[64]; + uint quick_n_ranges[64]; + ha_rows quick_condition_rows; + timestamp_auto_set_type timestamp_field_type; + table_map map; + uint lock_position; + uint lock_data_start; + uint lock_count; + uint tablenr,used_fields; + uint temp_pool_slot; + uint status; + uint db_stat; + uint derived_select_number; + int current_lock; + my_bool copy_blobs; + uint maybe_null; + my_bool null_row; + my_bool force_index; + my_bool distinct,const_table,no_rows; + my_bool key_read, no_keyread; + my_bool open_placeholder; + my_bool locked_by_logger; + my_bool no_replicate; + my_bool locked_by_name; + my_bool fulltext_searched; + my_bool no_cache; + my_bool open_by_handler; + my_bool auto_increment_field_not_null; + my_bool insert_or_update; + my_bool alias_name_used; + my_bool get_fields_in_item_tree; + my_bool children_attached; + REGINFO reginfo; + MEM_ROOT mem_root; + GRANT_INFO grant; + FILESORT_INFO sort; + In_C_you_should_use_my_bool_instead() fill_item_list(List<Item> *item_list) const; + void reset_item_list(List<Item> *item_list) const; + void clear_column_bitmaps(void); + void prepare_for_position(void); + void mark_columns_used_by_index_no_reset(uint index, MY_BITMAP *map); + void mark_columns_used_by_index(uint index); + void restore_column_maps_after_mark_index(); + void mark_auto_increment_column(void); + void mark_columns_needed_for_update(void); + void mark_columns_needed_for_delete(void); + void mark_columns_needed_for_insert(void); + inline void column_bitmaps_set(MY_BITMAP *read_set_arg, + MY_BITMAP *write_set_arg) + { + read_set= read_set_arg; + write_set= write_set_arg; + if (file) + file->column_bitmaps_signal(); + } + inline void column_bitmaps_set_no_signal(MY_BITMAP *read_set_arg, + MY_BITMAP *write_set_arg) + { + read_set= read_set_arg; + write_set= write_set_arg; + } + inline void use_all_columns() + { + column_bitmaps_set(&s->all_set, &s->all_set); + } + inline void default_column_bitmaps() + { + read_set= &def_read_set; + write_set= &def_write_set; + } + inline In_C_you_should_use_my_bool_instead() is_name_opened() { return db_stat || open_placeholder; } + inline In_C_you_should_use_my_bool_instead() needs_reopen_or_name_lock() + { return s->version != refresh_version; } + In_C_you_should_use_my_bool_instead() is_children_attached(void); +}; +enum enum_schema_table_state +{ + NOT_PROCESSED= 0, + PROCESSED_BY_CREATE_SORT_INDEX, + PROCESSED_BY_JOIN_EXEC +}; +typedef struct st_foreign_key_info +{ + LEX_STRING *forein_id; + LEX_STRING *referenced_db; + LEX_STRING *referenced_table; + LEX_STRING *update_method; + LEX_STRING *delete_method; + LEX_STRING *referenced_key_name; + List<LEX_STRING> foreign_fields; + List<LEX_STRING> referenced_fields; +} FOREIGN_KEY_INFO; +enum enum_schema_tables +{ + SCH_CHARSETS= 0, + SCH_COLLATIONS, + SCH_COLLATION_CHARACTER_SET_APPLICABILITY, + SCH_COLUMNS, + SCH_COLUMN_PRIVILEGES, + SCH_ENGINES, + SCH_EVENTS, + SCH_FILES, + SCH_GLOBAL_STATUS, + SCH_GLOBAL_VARIABLES, + SCH_KEY_COLUMN_USAGE, + SCH_OPEN_TABLES, + SCH_PARTITIONS, + SCH_PLUGINS, + SCH_PROCESSLIST, + SCH_PROFILES, + SCH_REFERENTIAL_CONSTRAINTS, + SCH_PROCEDURES, + SCH_SCHEMATA, + SCH_SCHEMA_PRIVILEGES, + SCH_SESSION_STATUS, + SCH_SESSION_VARIABLES, + SCH_STATISTICS, + SCH_STATUS, + SCH_TABLES, + SCH_TABLE_CONSTRAINTS, + SCH_TABLE_NAMES, + SCH_TABLE_PRIVILEGES, + SCH_TRIGGERS, + SCH_USER_PRIVILEGES, + SCH_VARIABLES, + SCH_VIEWS +}; +typedef struct st_field_info +{ + const char* field_name; + uint field_length; + enum enum_field_types field_type; + int value; + uint field_flags; + const char* old_name; + uint open_method; +} ST_FIELD_INFO; +struct TABLE_LIST; +typedef class Item COND; +typedef struct st_schema_table +{ + const char* table_name; + ST_FIELD_INFO *fields_info; + TABLE *(*create_table) (THD *thd, TABLE_LIST *table_list); + int (*fill_table) (THD *thd, TABLE_LIST *tables, COND *cond); + int (*old_format) (THD *thd, struct st_schema_table *schema_table); + int (*process_table) (THD *thd, TABLE_LIST *tables, TABLE *table, + In_C_you_should_use_my_bool_instead() res, LEX_STRING *db_name, LEX_STRING *table_name); + int idx_field1, idx_field2; + In_C_you_should_use_my_bool_instead() hidden; + uint i_s_requested_object; +} ST_SCHEMA_TABLE; +struct st_lex; +class select_union; +class TMP_TABLE_PARAM; +Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref, + const char *name); +struct Field_translator +{ + Item *item; + const char *name; +}; +class Natural_join_column: public Sql_alloc +{ +public: + Field_translator *view_field; + Field *table_field; + TABLE_LIST *table_ref; + In_C_you_should_use_my_bool_instead() is_common; +public: + Natural_join_column(Field_translator *field_param, TABLE_LIST *tab); + Natural_join_column(Field *field_param, TABLE_LIST *tab); + const char *name(); + Item *create_item(THD *thd); + Field *field(); + const char *table_name(); + const char *db_name(); + GRANT_INFO *grant(); +}; +class Index_hint; +struct TABLE_LIST +{ + TABLE_LIST() {} + inline void init_one_table(const char *db_name_arg, + const char *table_name_arg, + enum thr_lock_type lock_type_arg) + { + bzero((char*) this, sizeof(*this)); + db= (char*) db_name_arg; + table_name= alias= (char*) table_name_arg; + lock_type= lock_type_arg; + } + TABLE_LIST *next_local; + TABLE_LIST *next_global, **prev_global; + char *db, *alias, *table_name, *schema_table_name; + char *option; + Item *on_expr; + Item *prep_on_expr; + COND_EQUAL *cond_equal; + TABLE_LIST *natural_join; + In_C_you_should_use_my_bool_instead() is_natural_join; + List<String> *join_using_fields; + List<Natural_join_column> *join_columns; + In_C_you_should_use_my_bool_instead() is_join_columns_complete; + TABLE_LIST *next_name_resolution_table; + List<Index_hint> *index_hints; + TABLE *table; + uint table_id; + select_union *derived_result; + TABLE_LIST *correspondent_table; + st_select_lex_unit *derived; + ST_SCHEMA_TABLE *schema_table; + st_select_lex *schema_select_lex; + In_C_you_should_use_my_bool_instead() schema_table_reformed; + TMP_TABLE_PARAM *schema_table_param; + st_select_lex *select_lex; + st_lex *view; + Field_translator *field_translation; + Field_translator *field_translation_end; + TABLE_LIST *merge_underlying_list; + List<TABLE_LIST> *view_tables; + TABLE_LIST *belong_to_view; + TABLE_LIST *referencing_view; + TABLE_LIST *parent_l; + Security_context *security_ctx; + Security_context *view_sctx; + In_C_you_should_use_my_bool_instead() allowed_show; + TABLE_LIST *next_leaf; + Item *where; + Item *check_option; + LEX_STRING select_stmt; + LEX_STRING md5; + LEX_STRING source; + LEX_STRING view_db; + LEX_STRING view_name; + LEX_STRING timestamp; + st_lex_user definer; + ulonglong file_version; + ulonglong updatable_view; + ulonglong revision; + ulonglong algorithm; + ulonglong view_suid; + ulonglong with_check; + uint8 effective_with_check; + uint8 effective_algorithm; + GRANT_INFO grant; + ulonglong engine_data; + qc_engine_callback callback_func; + thr_lock_type lock_type; + uint outer_join; + uint shared; + size_t db_length; + size_t table_name_length; + In_C_you_should_use_my_bool_instead() updatable; + In_C_you_should_use_my_bool_instead() straight; + In_C_you_should_use_my_bool_instead() updating; + In_C_you_should_use_my_bool_instead() force_index; + In_C_you_should_use_my_bool_instead() ignore_leaves; + table_map dep_tables; + table_map on_expr_dep_tables; + struct st_nested_join *nested_join; + TABLE_LIST *embedding; + List<TABLE_LIST> *join_list; + In_C_you_should_use_my_bool_instead() cacheable_table; + In_C_you_should_use_my_bool_instead() table_in_first_from_clause; + In_C_you_should_use_my_bool_instead() skip_temporary; + In_C_you_should_use_my_bool_instead() contain_auto_increment; + In_C_you_should_use_my_bool_instead() multitable_view; + In_C_you_should_use_my_bool_instead() compact_view_format; + In_C_you_should_use_my_bool_instead() where_processed; + In_C_you_should_use_my_bool_instead() check_option_processed; + enum frm_type_enum required_type; + handlerton *db_type; + char timestamp_buffer[20]; + In_C_you_should_use_my_bool_instead() prelocking_placeholder; + In_C_you_should_use_my_bool_instead() create; + In_C_you_should_use_my_bool_instead() internal_tmp_table; + View_creation_ctx *view_creation_ctx; + LEX_STRING view_client_cs_name; + LEX_STRING view_connection_cl_name; + LEX_STRING view_body_utf8; + uint8 trg_event_map; + uint i_s_requested_object; + In_C_you_should_use_my_bool_instead() has_db_lookup_value; + In_C_you_should_use_my_bool_instead() has_table_lookup_value; + uint table_open_method; + enum enum_schema_table_state schema_table_state; + void calc_md5(char *buffer); + void set_underlying_merge(); + int view_check_option(THD *thd, In_C_you_should_use_my_bool_instead() ignore_failure); + In_C_you_should_use_my_bool_instead() setup_underlying(THD *thd); + void cleanup_items(); + In_C_you_should_use_my_bool_instead() placeholder() + { + return derived || view || schema_table || create && !table->db_stat || + !table; + } + void print(THD *thd, String *str, enum_query_type query_type); + In_C_you_should_use_my_bool_instead() check_single_table(TABLE_LIST **table, table_map map, + TABLE_LIST *view); + In_C_you_should_use_my_bool_instead() set_insert_values(MEM_ROOT *mem_root); + void hide_view_error(THD *thd); + TABLE_LIST *find_underlying_table(TABLE *table); + TABLE_LIST *first_leaf_for_name_resolution(); + TABLE_LIST *last_leaf_for_name_resolution(); + In_C_you_should_use_my_bool_instead() is_leaf_for_name_resolution(); + inline TABLE_LIST *top_table() + { return belong_to_view ? belong_to_view : this; } + inline In_C_you_should_use_my_bool_instead() prepare_check_option(THD *thd) + { + In_C_you_should_use_my_bool_instead() res= (0); + if (effective_with_check) + res= prep_check_option(thd, effective_with_check); + return res; + } + inline In_C_you_should_use_my_bool_instead() prepare_where(THD *thd, Item **conds, + In_C_you_should_use_my_bool_instead() no_where_clause) + { + if (effective_algorithm == 2) + return prep_where(thd, conds, no_where_clause); + return (0); + } + void register_want_access(ulong want_access); + In_C_you_should_use_my_bool_instead() prepare_security(THD *thd); + Security_context *find_view_security_context(THD *thd); + In_C_you_should_use_my_bool_instead() prepare_view_securety_context(THD *thd); + void reinit_before_use(THD *thd); + Item_subselect *containing_subselect(); + In_C_you_should_use_my_bool_instead() process_index_hints(TABLE *table); + inline ulong get_child_def_version() + { + return child_def_version; + } + inline void set_child_def_version(ulong version) + { + child_def_version= version; + } + inline void init_child_def_version() + { + child_def_version= ~0UL; + } + inline + In_C_you_should_use_my_bool_instead() is_table_ref_id_equal(TABLE_SHARE *s) const + { + return (m_table_ref_type == s->get_table_ref_type() && + m_table_ref_version == s->get_table_ref_version()); + } + inline + void set_table_ref_id(TABLE_SHARE *s) + { + m_table_ref_type= s->get_table_ref_type(); + m_table_ref_version= s->get_table_ref_version(); + } +private: + In_C_you_should_use_my_bool_instead() prep_check_option(THD *thd, uint8 check_opt_type); + In_C_you_should_use_my_bool_instead() prep_where(THD *thd, Item **conds, In_C_you_should_use_my_bool_instead() no_where_clause); + ulong child_def_version; + enum enum_table_ref_type m_table_ref_type; + ulong m_table_ref_version; +}; +class Item; +class Field_iterator: public Sql_alloc +{ +public: + Field_iterator() {} + virtual ~Field_iterator() {} + virtual void set(TABLE_LIST *)= 0; + virtual void next()= 0; + virtual In_C_you_should_use_my_bool_instead() end_of_fields()= 0; + virtual const char *name()= 0; + virtual Item *create_item(THD *)= 0; + virtual Field *field()= 0; +}; +class Field_iterator_table: public Field_iterator +{ + Field **ptr; +public: + Field_iterator_table() :ptr(0) {} + void set(TABLE_LIST *table) { ptr= table->table->field; } + void set_table(TABLE *table) { ptr= table->field; } + void next() { ptr++; } + In_C_you_should_use_my_bool_instead() end_of_fields() { return *ptr == 0; } + const char *name(); + Item *create_item(THD *thd); + Field *field() { return *ptr; } +}; +class Field_iterator_view: public Field_iterator +{ + Field_translator *ptr, *array_end; + TABLE_LIST *view; +public: + Field_iterator_view() :ptr(0), array_end(0) {} + void set(TABLE_LIST *table); + void next() { ptr++; } + In_C_you_should_use_my_bool_instead() end_of_fields() { return ptr == array_end; } + const char *name(); + Item *create_item(THD *thd); + Item **item_ptr() {return &ptr->item; } + Field *field() { return 0; } + inline Item *item() { return ptr->item; } + Field_translator *field_translator() { return ptr; } +}; +class Field_iterator_natural_join: public Field_iterator +{ + List_iterator_fast<Natural_join_column> column_ref_it; + Natural_join_column *cur_column_ref; +public: + Field_iterator_natural_join() :cur_column_ref(NULL) {} + ~Field_iterator_natural_join() {} + void set(TABLE_LIST *table); + void next(); + In_C_you_should_use_my_bool_instead() end_of_fields() { return !cur_column_ref; } + const char *name() { return cur_column_ref->name(); } + Item *create_item(THD *thd) { return cur_column_ref->create_item(thd); } + Field *field() { return cur_column_ref->field(); } + Natural_join_column *column_ref() { return cur_column_ref; } +}; +class Field_iterator_table_ref: public Field_iterator +{ + TABLE_LIST *table_ref, *first_leaf, *last_leaf; + Field_iterator_table table_field_it; + Field_iterator_view view_field_it; + Field_iterator_natural_join natural_join_it; + Field_iterator *field_it; + void set_field_iterator(); +public: + Field_iterator_table_ref() :field_it(NULL) {} + void set(TABLE_LIST *table); + void next(); + In_C_you_should_use_my_bool_instead() end_of_fields() + { return (table_ref == last_leaf && field_it->end_of_fields()); } + const char *name() { return field_it->name(); } + const char *table_name(); + const char *db_name(); + GRANT_INFO *grant(); + Item *create_item(THD *thd) { return field_it->create_item(thd); } + Field *field() { return field_it->field(); } + Natural_join_column *get_or_create_column_ref(TABLE_LIST *parent_table_ref); + Natural_join_column *get_natural_column_ref(); +}; +typedef struct st_nested_join +{ + List<TABLE_LIST> join_list; + table_map used_tables; + table_map not_null_tables; + struct st_join_table *first_nested; + uint counter; + nested_join_map nj_map; +} NESTED_JOIN; +typedef struct st_changed_table_list +{ + struct st_changed_table_list *next; + char *key; + uint32 key_length; +} CHANGED_TABLE_LIST; +typedef struct st_open_table_list{ + struct st_open_table_list *next; + char *db,*table; + uint32 in_use,locked; +} OPEN_TABLE_LIST; +typedef struct st_table_field_w_type +{ + LEX_STRING name; + LEX_STRING type; + LEX_STRING cset; +} TABLE_FIELD_W_TYPE; +my_bool +table_check_intact(TABLE *table, const uint table_f_count, + const TABLE_FIELD_W_TYPE *table_def); +static inline my_bitmap_map *tmp_use_all_columns(TABLE *table, + MY_BITMAP *bitmap) +{ + my_bitmap_map *old= bitmap->bitmap; + bitmap->bitmap= table->s->all_set.bitmap; + return old; +} +static inline void tmp_restore_column_map(MY_BITMAP *bitmap, + my_bitmap_map *old) +{ + bitmap->bitmap= old; +} +static inline my_bitmap_map *dbug_tmp_use_all_columns(TABLE *table, + MY_BITMAP *bitmap) +{ + return tmp_use_all_columns(table, bitmap); +} +static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap, + my_bitmap_map *old) +{ + tmp_restore_column_map(bitmap, old); +} +size_t max_row_length(TABLE *table, const uchar *data); +#include "sql_error.h" +class MYSQL_ERROR: public Sql_alloc +{ +public: + enum enum_warning_level + { WARN_LEVEL_NOTE, WARN_LEVEL_WARN, WARN_LEVEL_ERROR, WARN_LEVEL_END}; + uint code; + enum_warning_level level; + char *msg; + MYSQL_ERROR(THD *thd, uint code_arg, enum_warning_level level_arg, + const char *msg_arg) + :code(code_arg), level(level_arg) + { + if (msg_arg) + set_msg(thd, msg_arg); + } + void set_msg(THD *thd, const char *msg_arg); +}; +MYSQL_ERROR *push_warning(THD *thd, MYSQL_ERROR::enum_warning_level level, + uint code, const char *msg); +void push_warning_printf(THD *thd, MYSQL_ERROR::enum_warning_level level, + uint code, const char *format, ...); +void mysql_reset_errors(THD *thd, In_C_you_should_use_my_bool_instead() force); +In_C_you_should_use_my_bool_instead() mysqld_show_warnings(THD *thd, ulong levels_to_show); +extern const LEX_STRING warning_level_names[]; +#include "field.h" +const uint32 max_field_size= (uint32) 4294967295U; +class Send_field; +class Protocol; +class Create_field; +struct st_cache_field; +int field_conv(Field *to,Field *from); +inline uint get_enum_pack_length(int elements) +{ + return elements < 256 ? 1 : 2; +} +inline uint get_set_pack_length(int elements) +{ + uint len= (elements + 7) / 8; + return len > 4 ? 8 : len; +} +class Field +{ + Field(const Item &); + void operator=(Field &); +public: + static void *operator new(size_t size) {return sql_alloc(size); } + static void operator delete(void *ptr_arg, size_t size) { ; } + uchar *ptr; + uchar *null_ptr; + struct st_table *table; + struct st_table *orig_table; + const char **table_name, *field_name; + LEX_STRING comment; + key_map key_start, part_of_key, part_of_key_not_clustered; + key_map part_of_sortkey; + enum utype { NONE,DATE,SHIELD,NOEMPTY,CASEUP,PNR,BGNR,PGNR,YES,NO,REL, + CHECK,EMPTY,UNKNOWN_FIELD,CASEDN,NEXT_NUMBER,INTERVAL_FIELD, + BIT_FIELD, TIMESTAMP_OLD_FIELD, CAPITALIZE, BLOB_FIELD, + TIMESTAMP_DN_FIELD, TIMESTAMP_UN_FIELD, TIMESTAMP_DNUN_FIELD}; + enum geometry_type + { + GEOM_GEOMETRY = 0, GEOM_POINT = 1, GEOM_LINESTRING = 2, GEOM_POLYGON = 3, + GEOM_MULTIPOINT = 4, GEOM_MULTILINESTRING = 5, GEOM_MULTIPOLYGON = 6, + GEOM_GEOMETRYCOLLECTION = 7 + }; + enum imagetype { itRAW, itMBR}; + utype unireg_check; + uint32 field_length; + uint32 flags; + uint16 field_index; + uchar null_bit; + In_C_you_should_use_my_bool_instead() is_created_from_null_item; + Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, + uchar null_bit_arg, utype unireg_check_arg, + const char *field_name_arg); + virtual ~Field() {} + virtual int store(const char *to, uint length,CHARSET_INFO *cs)=0; + virtual int store(double nr)=0; + virtual int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val)=0; + virtual int store_decimal(const my_decimal *d)=0; + virtual int store_time(MYSQL_TIME *ltime, timestamp_type t_type); + int store(const char *to, uint length, CHARSET_INFO *cs, + enum_check_fields check_level); + virtual double val_real(void)=0; + virtual longlong val_int(void)=0; + virtual my_decimal *val_decimal(my_decimal *); + inline String *val_str(String *str) { return val_str(str, str); } + virtual String *val_str(String*,String *)=0; + String *val_int_as_str(String *val_buffer, my_bool unsigned_flag); + virtual In_C_you_should_use_my_bool_instead() str_needs_quotes() { return (0); } + virtual Item_result result_type () const=0; + virtual Item_result cmp_type () const { return result_type(); } + virtual Item_result cast_to_int_type () const { return result_type(); } + static In_C_you_should_use_my_bool_instead() type_can_have_key_part(enum_field_types); + static enum_field_types field_type_merge(enum_field_types, enum_field_types); + static Item_result result_merge_type(enum_field_types); + virtual In_C_you_should_use_my_bool_instead() eq(Field *field) + { + return (ptr == field->ptr && null_ptr == field->null_ptr && + null_bit == field->null_bit); + } + virtual In_C_you_should_use_my_bool_instead() eq_def(Field *field); + virtual uint32 pack_length() const { return (uint32) field_length; } + virtual uint32 pack_length_in_rec() const { return pack_length(); } + virtual int compatible_field_size(uint field_metadata); + virtual uint pack_length_from_metadata(uint field_metadata) + { return field_metadata; } + virtual uint row_pack_length() { return 0; } + virtual int save_field_metadata(uchar *first_byte) + { return do_save_field_metadata(first_byte); } + virtual uint32 data_length() { return pack_length(); } + virtual uint32 sort_length() const { return pack_length(); } + virtual uint32 max_data_length() const { + return pack_length(); + }; + virtual int reset(void) { bzero(ptr,pack_length()); return 0; } + virtual void reset_fields() {} + virtual void set_default() + { + my_ptrdiff_t l_offset= (my_ptrdiff_t) (table->s->default_values - + table->record[0]); + memcpy(ptr, ptr + l_offset, pack_length()); + if (null_ptr) + *null_ptr= ((*null_ptr & (uchar) ~null_bit) | + null_ptr[l_offset] & null_bit); + } + virtual In_C_you_should_use_my_bool_instead() binary() const { return 1; } + virtual In_C_you_should_use_my_bool_instead() zero_pack() const { return 1; } + virtual enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; } + virtual uint32 key_length() const { return pack_length(); } + virtual enum_field_types type() const =0; + virtual enum_field_types real_type() const { return type(); } + inline int cmp(const uchar *str) { return cmp(ptr,str); } + virtual int cmp_max(const uchar *a, const uchar *b, uint max_len) + { return cmp(a, b); } + virtual int cmp(const uchar *,const uchar *)=0; + virtual int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0L) + { return memcmp(a,b,pack_length()); } + virtual int cmp_offset(uint row_offset) + { return cmp(ptr,ptr+row_offset); } + virtual int cmp_binary_offset(uint row_offset) + { return cmp_binary(ptr, ptr+row_offset); }; + virtual int key_cmp(const uchar *a,const uchar *b) + { return cmp(a, b); } + virtual int key_cmp(const uchar *str, uint length) + { return cmp(ptr,str); } + virtual uint decimals() const { return 0; } + virtual void sql_type(String &str) const =0; + virtual uint size_of() const =0; + inline In_C_you_should_use_my_bool_instead() is_null(my_ptrdiff_t row_offset= 0) + { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : table->null_row; } + inline In_C_you_should_use_my_bool_instead() is_real_null(my_ptrdiff_t row_offset= 0) + { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : 0; } + inline In_C_you_should_use_my_bool_instead() is_null_in_record(const uchar *record) + { + if (!null_ptr) + return 0; + return ((record[(uint) (null_ptr -table->record[0])] & null_bit) ? 1 : 0); + } + inline In_C_you_should_use_my_bool_instead() is_null_in_record_with_offset(my_ptrdiff_t offset) + { + if (!null_ptr) + return 0; + return ((null_ptr[offset] & null_bit) ? 1 : 0); + } + inline void set_null(my_ptrdiff_t row_offset= 0) + { if (null_ptr) null_ptr[row_offset]|= null_bit; } + inline void set_notnull(my_ptrdiff_t row_offset= 0) + { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; } + inline In_C_you_should_use_my_bool_instead() maybe_null(void) { return null_ptr != 0 || table->maybe_null; } + inline In_C_you_should_use_my_bool_instead() real_maybe_null(void) { return null_ptr != 0; } + enum { + LAST_NULL_BYTE_UNDEF= 0 + }; + size_t last_null_byte() const { + size_t bytes= do_last_null_byte(); + do {_db_pargs_(284,"debug"); _db_doprnt_ ("last_null_byte() ==> %ld", (long) bytes);} while(0); + assert(bytes <= table->s->null_bytes); + return bytes; + } + virtual void make_field(Send_field *); + virtual void sort_string(uchar *buff,uint length)=0; + virtual In_C_you_should_use_my_bool_instead() optimize_range(uint idx, uint part); + virtual In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (0); } + virtual void free() {} + virtual Field *new_field(MEM_ROOT *root, struct st_table *new_table, + In_C_you_should_use_my_bool_instead() keep_type); + virtual Field *new_key_field(MEM_ROOT *root, struct st_table *new_table, + uchar *new_ptr, uchar *new_null_ptr, + uint new_null_bit); + Field *clone(MEM_ROOT *mem_root, struct st_table *new_table); + inline void move_field(uchar *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg) + { + ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg; + } + inline void move_field(uchar *ptr_arg) { ptr=ptr_arg; } + virtual void move_field_offset(my_ptrdiff_t ptr_diff) + { + ptr=(uchar*) ((uchar*) (ptr)+ptr_diff); + if (null_ptr) + null_ptr=(uchar*) ((uchar*) (null_ptr)+ptr_diff); + } + virtual void get_image(uchar *buff, uint length, CHARSET_INFO *cs) + { memcpy(buff,ptr,length); } + virtual void set_image(const uchar *buff,uint length, CHARSET_INFO *cs) + { memcpy(ptr,buff,length); } + virtual uint get_key_image(uchar *buff, uint length, imagetype type) + { + get_image(buff, length, &my_charset_bin); + return length; + } + virtual void set_key_image(const uchar *buff,uint length) + { set_image(buff,length, &my_charset_bin); } + inline longlong val_int_offset(uint row_offset) + { + ptr+=row_offset; + longlong tmp=val_int(); + ptr-=row_offset; + return tmp; + } + inline longlong val_int(const uchar *new_ptr) + { + uchar *old_ptr= ptr; + longlong return_value; + ptr= (uchar*) new_ptr; + return_value= val_int(); + ptr= old_ptr; + return return_value; + } + inline String *val_str(String *str, const uchar *new_ptr) + { + uchar *old_ptr= ptr; + ptr= (uchar*) new_ptr; + val_str(str); + ptr= old_ptr; + return str; + } + virtual In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + virtual uchar *pack(uchar *to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + uchar *pack(uchar *to, const uchar *from) + { + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("Field::pack","./sql/field.h",390,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + uchar *result= this->pack(to, from, UINT_MAX, table->s->db_low_byte_first); + do {_db_return_ (392, &_db_func_, &_db_file_, &_db_level_); return(result);} while(0); + } + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first); + const uchar *unpack(uchar* to, const uchar *from) + { + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("Field::unpack","./sql/field.h",402,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + const uchar *result= unpack(to, from, 0U, table->s->db_low_byte_first); + do {_db_return_ (404, &_db_func_, &_db_file_, &_db_level_); return(result);} while(0); + } + virtual uchar *pack_key(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + return pack(to, from, max_length, low_byte_first); + } + virtual uchar *pack_key_from_key_image(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + return pack(to, from, max_length, low_byte_first); + } + virtual const uchar *unpack_key(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + return unpack(to, from, max_length, low_byte_first); + } + virtual uint packed_col_length(const uchar *to, uint length) + { return length;} + virtual uint max_packed_col_length(uint max_length) + { return max_length;} + virtual int pack_cmp(const uchar *a,const uchar *b, uint key_length_arg, + my_bool insert_or_update) + { return cmp(a,b); } + virtual int pack_cmp(const uchar *b, uint key_length_arg, + my_bool insert_or_update) + { return cmp(ptr,b); } + uint offset(uchar *record) + { + return (uint) (ptr - record); + } + void copy_from_tmp(int offset); + uint fill_cache_field(struct st_cache_field *copy); + virtual In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + virtual In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); + virtual CHARSET_INFO *charset(void) const { return &my_charset_bin; } + virtual CHARSET_INFO *sort_charset(void) const { return charset(); } + virtual In_C_you_should_use_my_bool_instead() has_charset(void) const { return (0); } + virtual void set_charset(CHARSET_INFO *charset_arg) { } + virtual enum Derivation derivation(void) const + { return DERIVATION_IMPLICIT; } + virtual void set_derivation(enum Derivation derivation_arg) { } + In_C_you_should_use_my_bool_instead() set_warning(MYSQL_ERROR::enum_warning_level, unsigned int code, + int cuted_increment); + void set_datetime_warning(MYSQL_ERROR::enum_warning_level, uint code, + const char *str, uint str_len, + timestamp_type ts_type, int cuted_increment); + void set_datetime_warning(MYSQL_ERROR::enum_warning_level, uint code, + longlong nr, timestamp_type ts_type, + int cuted_increment); + void set_datetime_warning(MYSQL_ERROR::enum_warning_level, const uint code, + double nr, timestamp_type ts_type); + inline In_C_you_should_use_my_bool_instead() check_overflow(int op_result) + { + return (op_result == 2); + } + int warn_if_overflow(int op_result); + void init(TABLE *table_arg) + { + orig_table= table= table_arg; + table_name= &table_arg->alias; + } + virtual uint32 max_display_length()= 0; + virtual uint is_equal(Create_field *new_field); + longlong convert_decimal2longlong(const my_decimal *val, In_C_you_should_use_my_bool_instead() unsigned_flag, + int *err); + inline uint32 char_length() const + { + return field_length / charset()->mbmaxlen; + } + virtual geometry_type get_geometry_type() + { + assert(0); + return GEOM_GEOMETRY; + } + virtual void hash(ulong *nr, ulong *nr2); + friend In_C_you_should_use_my_bool_instead() reopen_table(THD *,struct st_table *,In_C_you_should_use_my_bool_instead()); + friend int cre_myisam(char * name, register TABLE *form, uint options, + ulonglong auto_increment_value); + friend class Copy_field; + friend class Item_avg_field; + friend class Item_std_field; + friend class Item_sum_num; + friend class Item_sum_sum; + friend class Item_sum_str; + friend class Item_sum_count; + friend class Item_sum_avg; + friend class Item_sum_std; + friend class Item_sum_min; + friend class Item_sum_max; + friend class Item_func_group_concat; +private: + virtual size_t do_last_null_byte() const; + virtual int do_save_field_metadata(uchar *metadata_ptr) + { return 0; } +}; +class Field_num :public Field { +public: + const uint8 dec; + In_C_you_should_use_my_bool_instead() zerofill,unsigned_flag; + Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, utype unireg_check_arg, + const char *field_name_arg, + uint8 dec_arg, In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg); + Item_result result_type () const { return REAL_RESULT; } + void prepend_zeros(String *value); + void add_zerofill_and_unsigned(String &res) const; + friend class Create_field; + void make_field(Send_field *); + uint decimals() const { return (uint) dec; } + uint size_of() const { return sizeof(*this); } + In_C_you_should_use_my_bool_instead() eq_def(Field *field); + int store_decimal(const my_decimal *); + my_decimal *val_decimal(my_decimal *); + uint is_equal(Create_field *new_field); + int check_int(CHARSET_INFO *cs, const char *str, int length, + const char *int_end, int error); + In_C_you_should_use_my_bool_instead() get_int(CHARSET_INFO *cs, const char *from, uint len, + longlong *rnd, ulonglong unsigned_max, + longlong signed_min, longlong signed_max); +}; +class Field_str :public Field { +protected: + CHARSET_INFO *field_charset; + enum Derivation field_derivation; +public: + Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, utype unireg_check_arg, + const char *field_name_arg, CHARSET_INFO *charset); + Item_result result_type () const { return STRING_RESULT; } + uint decimals() const { return 31; } + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val)=0; + int store_decimal(const my_decimal *); + int store(const char *to,uint length,CHARSET_INFO *cs)=0; + uint size_of() const { return sizeof(*this); } + CHARSET_INFO *charset(void) const { return field_charset; } + void set_charset(CHARSET_INFO *charset_arg) { field_charset= charset_arg; } + enum Derivation derivation(void) const { return field_derivation; } + virtual void set_derivation(enum Derivation derivation_arg) + { field_derivation= derivation_arg; } + In_C_you_should_use_my_bool_instead() binary() const { return field_charset == &my_charset_bin; } + uint32 max_display_length() { return field_length; } + friend class Create_field; + my_decimal *val_decimal(my_decimal *); + virtual In_C_you_should_use_my_bool_instead() str_needs_quotes() { return (1); } + In_C_you_should_use_my_bool_instead() compare_str_field_flags(Create_field *new_field, uint32 flags); + uint is_equal(Create_field *new_field); +}; +class Field_longstr :public Field_str +{ +protected: + int report_if_important_data(const char *ptr, const char *end, + In_C_you_should_use_my_bool_instead() count_spaces); +public: + Field_longstr(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, utype unireg_check_arg, + const char *field_name_arg, CHARSET_INFO *charset_arg) + :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg, + field_name_arg, charset_arg) + {} + int store_decimal(const my_decimal *d); + uint32 max_data_length() const; +}; +class Field_real :public Field_num { +public: + my_bool not_fixed; + Field_real(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, utype unireg_check_arg, + const char *field_name_arg, + uint8 dec_arg, In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg, + field_name_arg, dec_arg, zero_arg, unsigned_arg), + not_fixed(dec_arg >= 31) + {} + int store_decimal(const my_decimal *); + my_decimal *val_decimal(my_decimal *); + int truncate(double *nr, double max_length); + uint32 max_display_length() { return field_length; } + uint size_of() const { return sizeof(*this); } + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first); + virtual uchar *pack(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); +}; +class Field_decimal :public Field_real { +public: + Field_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + uint8 dec_arg,In_C_you_should_use_my_bool_instead() zero_arg,In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + dec_arg, zero_arg, unsigned_arg) + {} + enum_field_types type() const { return MYSQL_TYPE_DECIMAL;} + enum ha_base_keytype key_type() const + { return zerofill ? HA_KEYTYPE_BINARY : HA_KEYTYPE_NUM; } + int reset(void); + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + void overflow(In_C_you_should_use_my_bool_instead() negative); + In_C_you_should_use_my_bool_instead() zero_pack() const { return 0; } + void sql_type(String &str) const; + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first) + { + return Field::unpack(to, from, param_data, low_byte_first); + } + virtual uchar *pack(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + return Field::pack(to, from, max_length, low_byte_first); + } +}; +class Field_new_decimal :public Field_num { +private: + int do_save_field_metadata(uchar *first_byte); +public: + uint precision; + uint bin_size; + Field_new_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + uint8 dec_arg, In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg); + Field_new_decimal(uint32 len_arg, In_C_you_should_use_my_bool_instead() maybe_null_arg, + const char *field_name_arg, uint8 dec_arg, + In_C_you_should_use_my_bool_instead() unsigned_arg); + enum_field_types type() const { return MYSQL_TYPE_NEWDECIMAL;} + enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; } + Item_result result_type () const { return DECIMAL_RESULT; } + int reset(void); + In_C_you_should_use_my_bool_instead() store_value(const my_decimal *decimal_value); + void set_value_on_overflow(my_decimal *decimal_value, In_C_you_should_use_my_bool_instead() sign); + int store(const char *to, uint length, CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int store_time(MYSQL_TIME *ltime, timestamp_type t_type); + int store_decimal(const my_decimal *); + double val_real(void); + longlong val_int(void); + my_decimal *val_decimal(my_decimal *); + String *val_str(String*, String *); + int cmp(const uchar *, const uchar *); + void sort_string(uchar *buff, uint length); + In_C_you_should_use_my_bool_instead() zero_pack() const { return 0; } + void sql_type(String &str) const; + uint32 max_display_length() { return field_length; } + uint size_of() const { return sizeof(*this); } + uint32 pack_length() const { return (uint32) bin_size; } + uint pack_length_from_metadata(uint field_metadata); + uint row_pack_length() { return pack_length(); } + int compatible_field_size(uint field_metadata); + uint is_equal(Create_field *new_field); + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first); +}; +class Field_tiny :public Field_num { +public: + Field_tiny(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + 0, zero_arg,unsigned_arg) + {} + enum Item_result result_type () const { return INT_RESULT; } + enum_field_types type() const { return MYSQL_TYPE_TINY;} + enum ha_base_keytype key_type() const + { return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { ptr[0]=0; return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 1; } + void sql_type(String &str) const; + uint32 max_display_length() { return 4; } + virtual uchar *pack(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + *to= *from; + return to + 1; + } + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first) + { + *to= *from; + return from + 1; + } +}; +class Field_short :public Field_num { +public: + Field_short(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + 0, zero_arg,unsigned_arg) + {} + Field_short(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0, + NONE, field_name_arg, 0, 0, unsigned_arg) + {} + enum Item_result result_type () const { return INT_RESULT; } + enum_field_types type() const { return MYSQL_TYPE_SHORT;} + enum ha_base_keytype key_type() const + { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;} + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { ptr[0]=ptr[1]=0; return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 2; } + void sql_type(String &str) const; + uint32 max_display_length() { return 6; } + virtual uchar *pack(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + int16 val; + do { val = (*((int16 *) (from))); } while(0); + *((uint16*) (to))= (uint16) (val); + return to + sizeof(val); + } + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first) + { + int16 val; + do { val = (*((int16 *) (from))); } while(0); + *((uint16*) (to))= (uint16) (val); + return from + sizeof(val); + } +}; +class Field_medium :public Field_num { +public: + Field_medium(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + 0, zero_arg,unsigned_arg) + {} + enum Item_result result_type () const { return INT_RESULT; } + enum_field_types type() const { return MYSQL_TYPE_INT24;} + enum ha_base_keytype key_type() const + { return unsigned_flag ? HA_KEYTYPE_UINT24 : HA_KEYTYPE_INT24; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 3; } + void sql_type(String &str) const; + uint32 max_display_length() { return 8; } + virtual uchar *pack(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + return Field::pack(to, from, max_length, low_byte_first); + } + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first) + { + return Field::unpack(to, from, param_data, low_byte_first); + } +}; +class Field_long :public Field_num { +public: + Field_long(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + 0, zero_arg,unsigned_arg) + {} + Field_long(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0, + NONE, field_name_arg,0,0,unsigned_arg) + {} + enum Item_result result_type () const { return INT_RESULT; } + enum_field_types type() const { return MYSQL_TYPE_LONG;} + enum ha_base_keytype key_type() const + { return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; } + double val_real(void); + longlong val_int(void); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + String *val_str(String*,String *); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 4; } + void sql_type(String &str) const; + uint32 max_display_length() { return 11; } + virtual uchar *pack(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + int32 val; + do { val = (*((long *) (from))); } while(0); + *((long *) (to))= (long) (val); + return to + sizeof(val); + } + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first) + { + int32 val; + do { val = (*((long *) (from))); } while(0); + *((long *) (to))= (long) (val); + return from + sizeof(val); + } +}; +class Field_longlong :public Field_num { +public: + Field_longlong(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() zero_arg, In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + 0, zero_arg,unsigned_arg) + {} + Field_longlong(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, + const char *field_name_arg, + In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0, + NONE, field_name_arg,0,0,unsigned_arg) + {} + enum Item_result result_type () const { return INT_RESULT; } + enum_field_types type() const { return MYSQL_TYPE_LONGLONG;} + enum ha_base_keytype key_type() const + { return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) + { + ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; + return 0; + } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 8; } + void sql_type(String &str) const; + In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (1); } + uint32 max_display_length() { return 20; } + virtual uchar *pack(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first) + { + int64 val; + memcpy(((uchar*) &val),((uchar*) (from)),(sizeof(ulonglong))); + memcpy(((uchar*) (to)),((uchar*) &val),(sizeof(ulonglong))); + return to + sizeof(val); + } + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first) + { + int64 val; + memcpy(((uchar*) &val),((uchar*) (from)),(sizeof(ulonglong))); + memcpy(((uchar*) (to)),((uchar*) &val),(sizeof(ulonglong))); + return from + sizeof(val); + } +}; +class Field_float :public Field_real { +public: + Field_float(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + uint8 dec_arg,In_C_you_should_use_my_bool_instead() zero_arg,In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + dec_arg, zero_arg, unsigned_arg) + {} + Field_float(uint32 len_arg, In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + uint8 dec_arg) + :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0, + NONE, field_name_arg, dec_arg, 0, 0) + {} + enum_field_types type() const { return MYSQL_TYPE_FLOAT;} + enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { bzero(ptr,sizeof(float)); return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return sizeof(float); } + uint row_pack_length() { return pack_length(); } + void sql_type(String &str) const; +private: + int do_save_field_metadata(uchar *first_byte); +}; +class Field_double :public Field_real { +public: + Field_double(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + uint8 dec_arg,In_C_you_should_use_my_bool_instead() zero_arg,In_C_you_should_use_my_bool_instead() unsigned_arg) + :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + dec_arg, zero_arg, unsigned_arg) + {} + Field_double(uint32 len_arg, In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + uint8 dec_arg) + :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0, + NONE, field_name_arg, dec_arg, 0, 0) + {} + Field_double(uint32 len_arg, In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + uint8 dec_arg, my_bool not_fixed_arg) + :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0, + NONE, field_name_arg, dec_arg, 0, 0) + {not_fixed= not_fixed_arg; } + enum_field_types type() const { return MYSQL_TYPE_DOUBLE;} + enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { bzero(ptr,sizeof(double)); return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return sizeof(double); } + uint row_pack_length() { return pack_length(); } + void sql_type(String &str) const; +private: + int do_save_field_metadata(uchar *first_byte); +}; +class Field_null :public Field_str { + static uchar null[1]; +public: + Field_null(uchar *ptr_arg, uint32 len_arg, + enum utype unireg_check_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str(ptr_arg, len_arg, null, 1, + unireg_check_arg, field_name_arg, cs) + {} + enum_field_types type() const { return MYSQL_TYPE_NULL;} + int store(const char *to, uint length, CHARSET_INFO *cs) + { null[0]=1; return 0; } + int store(double nr) { null[0]=1; return 0; } + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val) { null[0]=1; return 0; } + int store_decimal(const my_decimal *d) { null[0]=1; return 0; } + int reset(void) { return 0; } + double val_real(void) { return 0.0;} + longlong val_int(void) { return 0;} + my_decimal *val_decimal(my_decimal *) { return 0; } + String *val_str(String *value,String *value2) + { value2->length(0); return value2;} + int cmp(const uchar *a, const uchar *b) { return 0;} + void sort_string(uchar *buff, uint length) {} + uint32 pack_length() const { return 0; } + void sql_type(String &str) const; + uint size_of() const { return sizeof(*this); } + uint32 max_display_length() { return 4; } +}; +class Field_timestamp :public Field_str { +public: + Field_timestamp(uchar *ptr_arg, uint32 len_arg, + uchar *null_ptr_arg, uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + TABLE_SHARE *share, CHARSET_INFO *cs); + Field_timestamp(In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs); + enum_field_types type() const { return MYSQL_TYPE_TIMESTAMP;} + enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; } + enum Item_result cmp_type () const { return INT_RESULT; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 4; } + void sql_type(String &str) const; + In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (1); } + In_C_you_should_use_my_bool_instead() zero_pack() const { return 0; } + void set_time(); + virtual void set_default() + { + if (table->timestamp_field == this && + unireg_check != TIMESTAMP_UN_FIELD) + set_time(); + else + Field::set_default(); + } + inline long get_timestamp(my_bool *null_value) + { + if ((*null_value= is_null())) + return 0; + long tmp; + do { tmp = (*((long *) (ptr))); } while(0); + return tmp; + } + inline void store_timestamp(my_time_t timestamp) + { + *((long *) (ptr))= (long) ((uint32) timestamp); + } + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); + timestamp_auto_set_type get_auto_set_type() const; +}; +class Field_year :public Field_tiny { +public: + Field_year(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg) + :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, 1, 1) + {} + enum_field_types type() const { return MYSQL_TYPE_YEAR;} + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + void sql_type(String &str) const; + In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (1); } +}; +class Field_date :public Field_str { +public: + Field_date(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, cs) + {} + Field_date(In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str((uchar*) 0,10, maybe_null_arg ? (uchar*) "": 0,0, + NONE, field_name_arg, cs) {} + enum_field_types type() const { return MYSQL_TYPE_DATE;} + enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; } + enum Item_result cmp_type () const { return INT_RESULT; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 4; } + void sql_type(String &str) const; + In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (1); } + In_C_you_should_use_my_bool_instead() zero_pack() const { return 1; } +}; +class Field_newdate :public Field_str { +public: + Field_newdate(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, cs) + {} + Field_newdate(In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str((uchar*) 0,10, maybe_null_arg ? (uchar*) "": 0,0, + NONE, field_name_arg, cs) {} + enum_field_types type() const { return MYSQL_TYPE_DATE;} + enum_field_types real_type() const { return MYSQL_TYPE_NEWDATE; } + enum ha_base_keytype key_type() const { return HA_KEYTYPE_UINT24; } + enum Item_result cmp_type () const { return INT_RESULT; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int store_time(MYSQL_TIME *ltime, timestamp_type type); + int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 3; } + void sql_type(String &str) const; + In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (1); } + In_C_you_should_use_my_bool_instead() zero_pack() const { return 1; } + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); +}; +class Field_time :public Field_str { +public: + Field_time(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, cs) + {} + Field_time(In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str((uchar*) 0,8, maybe_null_arg ? (uchar*) "": 0,0, + NONE, field_name_arg, cs) {} + enum_field_types type() const { return MYSQL_TYPE_TIME;} + enum ha_base_keytype key_type() const { return HA_KEYTYPE_INT24; } + enum Item_result cmp_type () const { return INT_RESULT; } + int store_time(MYSQL_TIME *ltime, timestamp_type type); + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime, uint fuzzydate); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 3; } + void sql_type(String &str) const; + In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (1); } + In_C_you_should_use_my_bool_instead() zero_pack() const { return 1; } +}; +class Field_datetime :public Field_str { +public: + Field_datetime(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, cs) + {} + Field_datetime(In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_str((uchar*) 0,19, maybe_null_arg ? (uchar*) "": 0,0, + NONE, field_name_arg, cs) {} + enum_field_types type() const { return MYSQL_TYPE_DATETIME;} + enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; } + enum Item_result cmp_type () const { return INT_RESULT; } + uint decimals() const { return 6; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int store_time(MYSQL_TIME *ltime, timestamp_type type); + int reset(void) + { + ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; + return 0; + } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + In_C_you_should_use_my_bool_instead() send_binary(Protocol *protocol); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return 8; } + void sql_type(String &str) const; + In_C_you_should_use_my_bool_instead() can_be_compared_as_longlong() const { return (1); } + In_C_you_should_use_my_bool_instead() zero_pack() const { return 1; } + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); +}; +class Field_string :public Field_longstr { +public: + In_C_you_should_use_my_bool_instead() can_alter_field_type; + Field_string(uchar *ptr_arg, uint32 len_arg,uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, cs), + can_alter_field_type(1) {}; + Field_string(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0, + NONE, field_name_arg, cs), + can_alter_field_type(1) {}; + enum_field_types type() const + { + return ((can_alter_field_type && orig_table && + orig_table->s->db_create_options & 1 && + field_length >= 4) && + orig_table->s->frm_version < (6 +4) ? + MYSQL_TYPE_VAR_STRING : MYSQL_TYPE_STRING); + } + enum ha_base_keytype key_type() const + { return binary() ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; } + In_C_you_should_use_my_bool_instead() zero_pack() const { return 0; } + int reset(void) + { + charset()->cset->fill(charset(),(char*) ptr, field_length, + (has_charset() ? ' ' : 0)); + return 0; + } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int store(double nr) { return Field_str::store(nr); } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + my_decimal *val_decimal(my_decimal *); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + void sql_type(String &str) const; + virtual uchar *pack(uchar *to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first); + uint pack_length_from_metadata(uint field_metadata) + { return (field_metadata & 0x00ff); } + uint row_pack_length() { return (field_length + 1); } + int pack_cmp(const uchar *a,const uchar *b,uint key_length, + my_bool insert_or_update); + int pack_cmp(const uchar *b,uint key_length,my_bool insert_or_update); + uint packed_col_length(const uchar *to, uint length); + uint max_packed_col_length(uint max_length); + uint size_of() const { return sizeof(*this); } + enum_field_types real_type() const { return MYSQL_TYPE_STRING; } + In_C_you_should_use_my_bool_instead() has_charset(void) const + { return charset() == &my_charset_bin ? (0) : (1); } + Field *new_field(MEM_ROOT *root, struct st_table *new_table, In_C_you_should_use_my_bool_instead() keep_type); + virtual uint get_key_image(uchar *buff,uint length, imagetype type); +private: + int do_save_field_metadata(uchar *first_byte); +}; +class Field_varstring :public Field_longstr { +public: + static const uint MAX_SIZE; + uint32 length_bytes; + Field_varstring(uchar *ptr_arg, + uint32 len_arg, uint length_bytes_arg, + uchar *null_ptr_arg, uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + TABLE_SHARE *share, CHARSET_INFO *cs) + :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, cs), + length_bytes(length_bytes_arg) + { + share->varchar_fields++; + } + Field_varstring(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, + const char *field_name_arg, + TABLE_SHARE *share, CHARSET_INFO *cs) + :Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0, + NONE, field_name_arg, cs), + length_bytes(len_arg < 256 ? 1 :2) + { + share->varchar_fields++; + } + enum_field_types type() const { return MYSQL_TYPE_VARCHAR; } + enum ha_base_keytype key_type() const; + uint row_pack_length() { return field_length; } + In_C_you_should_use_my_bool_instead() zero_pack() const { return 0; } + int reset(void) { bzero(ptr,field_length+length_bytes); return 0; } + uint32 pack_length() const { return (uint32) field_length+length_bytes; } + uint32 key_length() const { return (uint32) field_length; } + uint32 sort_length() const + { + return (uint32) field_length + (field_charset == &my_charset_bin ? + length_bytes : 0); + } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int store(double nr) { return Field_str::store(nr); } + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + my_decimal *val_decimal(my_decimal *); + int cmp_max(const uchar *, const uchar *, uint max_length); + int cmp(const uchar *a,const uchar *b) + { + return cmp_max(a, b, ~0L); + } + void sort_string(uchar *buff,uint length); + uint get_key_image(uchar *buff,uint length, imagetype type); + void set_key_image(const uchar *buff,uint length); + void sql_type(String &str) const; + virtual uchar *pack(uchar *to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + uchar *pack_key(uchar *to, const uchar *from, uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + uchar *pack_key_from_key_image(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + virtual const uchar *unpack(uchar* to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first); + const uchar *unpack_key(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + int pack_cmp(const uchar *a, const uchar *b, uint key_length, + my_bool insert_or_update); + int pack_cmp(const uchar *b, uint key_length,my_bool insert_or_update); + int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0L); + int key_cmp(const uchar *,const uchar*); + int key_cmp(const uchar *str, uint length); + uint packed_col_length(const uchar *to, uint length); + uint max_packed_col_length(uint max_length); + uint32 data_length(); + uint size_of() const { return sizeof(*this); } + enum_field_types real_type() const { return MYSQL_TYPE_VARCHAR; } + In_C_you_should_use_my_bool_instead() has_charset(void) const + { return charset() == &my_charset_bin ? (0) : (1); } + Field *new_field(MEM_ROOT *root, struct st_table *new_table, In_C_you_should_use_my_bool_instead() keep_type); + Field *new_key_field(MEM_ROOT *root, struct st_table *new_table, + uchar *new_ptr, uchar *new_null_ptr, + uint new_null_bit); + uint is_equal(Create_field *new_field); + void hash(ulong *nr, ulong *nr2); +private: + int do_save_field_metadata(uchar *first_byte); +}; +class Field_blob :public Field_longstr { +protected: + uint packlength; + String value; +public: + Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + TABLE_SHARE *share, uint blob_pack_length, CHARSET_INFO *cs); + Field_blob(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs) + :Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0, + NONE, field_name_arg, cs), + packlength(4) + { + flags|= 16; + } + Field_blob(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + CHARSET_INFO *cs, In_C_you_should_use_my_bool_instead() set_packlength) + :Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0, + NONE, field_name_arg, cs) + { + flags|= 16; + packlength= 4; + if (set_packlength) + { + uint32 l_char_length= len_arg/cs->mbmaxlen; + packlength= l_char_length <= 255 ? 1 : + l_char_length <= 65535 ? 2 : + l_char_length <= 16777215 ? 3 : 4; + } + } + Field_blob(uint32 packlength_arg) + :Field_longstr((uchar*) 0, 0, (uchar*) "", 0, NONE, "temp", system_charset_info), + packlength(packlength_arg) {} + enum_field_types type() const { return MYSQL_TYPE_BLOB;} + enum ha_base_keytype key_type() const + { return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + my_decimal *val_decimal(my_decimal *); + int cmp_max(const uchar *, const uchar *, uint max_length); + int cmp(const uchar *a,const uchar *b) + { return cmp_max(a, b, ~0L); } + int cmp(const uchar *a, uint32 a_length, const uchar *b, uint32 b_length); + int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0L); + int key_cmp(const uchar *,const uchar*); + int key_cmp(const uchar *str, uint length); + uint32 key_length() const { return 0; } + void sort_string(uchar *buff,uint length); + uint32 pack_length() const + { return (uint32) (packlength+table->s->blob_ptr_size); } + uint32 pack_length_no_ptr() const + { return (uint32) (packlength); } + uint row_pack_length() { return pack_length_no_ptr(); } + uint32 sort_length() const; + virtual uint32 max_data_length() const + { + return (uint32) (((ulonglong) 1 << (packlength*8)) -1); + } + int reset(void) { bzero(ptr, packlength+sizeof(uchar*)); return 0; } + void reset_fields() { bzero((uchar*) &value,sizeof(value)); } + static + void store_length(uchar *i_ptr, uint i_packlength, uint32 i_number, In_C_you_should_use_my_bool_instead() low_byte_first); + void store_length(uchar *i_ptr, uint i_packlength, uint32 i_number) + { + store_length(i_ptr, i_packlength, i_number, table->s->db_low_byte_first); + } + inline void store_length(uint32 number) + { + store_length(ptr, packlength, number); + } + uint32 get_packed_size(const uchar *ptr_arg, In_C_you_should_use_my_bool_instead() low_byte_first) + {return packlength + get_length(ptr_arg, packlength, low_byte_first);} + inline uint32 get_length(uint row_offset= 0) + { return get_length(ptr+row_offset, this->packlength, table->s->db_low_byte_first); } + uint32 get_length(const uchar *ptr, uint packlength, In_C_you_should_use_my_bool_instead() low_byte_first); + uint32 get_length(const uchar *ptr_arg) + { return get_length(ptr_arg, this->packlength, table->s->db_low_byte_first); } + void put_length(uchar *pos, uint32 length); + inline void get_ptr(uchar **str) + { + memcpy(((uchar*) str),(ptr+packlength),(sizeof(uchar*))); + } + inline void get_ptr(uchar **str, uint row_offset) + { + memcpy(((uchar*) str),(ptr+packlength+row_offset),(sizeof(char*))); + } + inline void set_ptr(uchar *length, uchar *data) + { + memcpy(ptr,length,packlength); + memcpy((ptr+packlength),(&data),(sizeof(char*))); + } + void set_ptr_offset(my_ptrdiff_t ptr_diff, uint32 length, uchar *data) + { + uchar *ptr_ofs= (uchar*) ((uchar*) (ptr)+ptr_diff); + store_length(ptr_ofs, packlength, length); + memcpy((ptr_ofs+packlength),(&data),(sizeof(char*))); + } + inline void set_ptr(uint32 length, uchar *data) + { + set_ptr_offset(0, length, data); + } + uint get_key_image(uchar *buff,uint length, imagetype type); + void set_key_image(const uchar *buff,uint length); + void sql_type(String &str) const; + inline In_C_you_should_use_my_bool_instead() copy() + { + uchar *tmp; + get_ptr(&tmp); + if (value.copy((char*) tmp, get_length(), charset())) + { + Field_blob::reset(); + return 1; + } + tmp=(uchar*) value.ptr(); + memcpy((ptr+packlength),(&tmp),(sizeof(char*))); + return 0; + } + virtual uchar *pack(uchar *to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + uchar *pack_key(uchar *to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + uchar *pack_key_from_key_image(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + virtual const uchar *unpack(uchar *to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first); + const uchar *unpack_key(uchar* to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + int pack_cmp(const uchar *a, const uchar *b, uint key_length, + my_bool insert_or_update); + int pack_cmp(const uchar *b, uint key_length,my_bool insert_or_update); + uint packed_col_length(const uchar *col_ptr, uint length); + uint max_packed_col_length(uint max_length); + void free() { value.free(); } + inline void clear_temporary() { bzero((uchar*) &value,sizeof(value)); } + friend int field_conv(Field *to,Field *from); + uint size_of() const { return sizeof(*this); } + In_C_you_should_use_my_bool_instead() has_charset(void) const + { return charset() == &my_charset_bin ? (0) : (1); } + uint32 max_display_length(); + uint is_equal(Create_field *new_field); + inline In_C_you_should_use_my_bool_instead() in_read_set() { return bitmap_is_set(table->read_set, field_index); } + inline In_C_you_should_use_my_bool_instead() in_write_set() { return bitmap_is_set(table->write_set, field_index); } +private: + int do_save_field_metadata(uchar *first_byte); +}; +class Field_geom :public Field_blob { +public: + enum geometry_type geom_type; + Field_geom(uchar *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + TABLE_SHARE *share, uint blob_pack_length, + enum geometry_type geom_type_arg) + :Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, unireg_check_arg, + field_name_arg, share, blob_pack_length, &my_charset_bin) + { geom_type= geom_type_arg; } + Field_geom(uint32 len_arg,In_C_you_should_use_my_bool_instead() maybe_null_arg, const char *field_name_arg, + TABLE_SHARE *share, enum geometry_type geom_type_arg) + :Field_blob(len_arg, maybe_null_arg, field_name_arg, &my_charset_bin) + { geom_type= geom_type_arg; } + enum ha_base_keytype key_type() const { return HA_KEYTYPE_VARBINARY2; } + enum_field_types type() const { return MYSQL_TYPE_GEOMETRY; } + void sql_type(String &str) const; + int store(const char *to, uint length, CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int store_decimal(const my_decimal *); + uint size_of() const { return sizeof(*this); } + int reset(void) { return !maybe_null() || Field_blob::reset(); } + geometry_type get_geometry_type() { return geom_type; }; +}; +class Field_enum :public Field_str { +protected: + uint packlength; +public: + TYPELIB *typelib; + Field_enum(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + uint packlength_arg, + TYPELIB *typelib_arg, + CHARSET_INFO *charset_arg) + :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, charset_arg), + packlength(packlength_arg),typelib(typelib_arg) + { + flags|=256; + } + Field *new_field(MEM_ROOT *root, struct st_table *new_table, In_C_you_should_use_my_bool_instead() keep_type); + enum_field_types type() const { return MYSQL_TYPE_STRING; } + enum Item_result cmp_type () const { return INT_RESULT; } + enum Item_result cast_to_int_type () const { return INT_RESULT; } + enum ha_base_keytype key_type() const; + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + double val_real(void); + longlong val_int(void); + String *val_str(String*,String *); + int cmp(const uchar *,const uchar *); + void sort_string(uchar *buff,uint length); + uint32 pack_length() const { return (uint32) packlength; } + void store_type(ulonglong value); + void sql_type(String &str) const; + uint size_of() const { return sizeof(*this); } + enum_field_types real_type() const { return MYSQL_TYPE_ENUM; } + uint pack_length_from_metadata(uint field_metadata) + { return (field_metadata & 0x00ff); } + uint row_pack_length() { return pack_length(); } + virtual In_C_you_should_use_my_bool_instead() zero_pack() const { return 0; } + In_C_you_should_use_my_bool_instead() optimize_range(uint idx, uint part) { return 0; } + In_C_you_should_use_my_bool_instead() eq_def(Field *field); + In_C_you_should_use_my_bool_instead() has_charset(void) const { return (1); } + CHARSET_INFO *sort_charset(void) const { return &my_charset_bin; } +private: + int do_save_field_metadata(uchar *first_byte); +}; +class Field_set :public Field_enum { +public: + Field_set(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg, + uint32 packlength_arg, + TYPELIB *typelib_arg, CHARSET_INFO *charset_arg) + :Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, + packlength_arg, + typelib_arg,charset_arg) + { + flags=(flags & ~256) | 2048; + } + int store(const char *to,uint length,CHARSET_INFO *charset); + int store(double nr) { return Field_set::store((longlong) nr, (0)); } + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + virtual In_C_you_should_use_my_bool_instead() zero_pack() const { return 1; } + String *val_str(String*,String *); + void sql_type(String &str) const; + enum_field_types real_type() const { return MYSQL_TYPE_SET; } + In_C_you_should_use_my_bool_instead() has_charset(void) const { return (1); } +}; +class Field_bit :public Field { +public: + uchar *bit_ptr; + uchar bit_ofs; + uint bit_len; + uint bytes_in_rec; + Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg, + enum utype unireg_check_arg, const char *field_name_arg); + enum_field_types type() const { return MYSQL_TYPE_BIT; } + enum ha_base_keytype key_type() const { return HA_KEYTYPE_BIT; } + uint32 key_length() const { return (uint32) (field_length + 7) / 8; } + uint32 max_data_length() const { return (field_length + 7) / 8; } + uint32 max_display_length() { return field_length; } + uint size_of() const { return sizeof(*this); } + Item_result result_type () const { return INT_RESULT; } + int reset(void) { bzero(ptr, bytes_in_rec); return 0; } + int store(const char *to, uint length, CHARSET_INFO *charset); + int store(double nr); + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val); + int store_decimal(const my_decimal *); + double val_real(void); + longlong val_int(void); + String *val_str(String*, String *); + virtual In_C_you_should_use_my_bool_instead() str_needs_quotes() { return (1); } + my_decimal *val_decimal(my_decimal *); + int cmp(const uchar *a, const uchar *b) + { + assert(ptr == a); + return Field_bit::key_cmp(b, bytes_in_rec+((bit_len) ? 1 : 0)); + } + int cmp_binary_offset(uint row_offset) + { return cmp_offset(row_offset); } + int cmp_max(const uchar *a, const uchar *b, uint max_length); + int key_cmp(const uchar *a, const uchar *b) + { return cmp_binary((uchar *) a, (uchar *) b); } + int key_cmp(const uchar *str, uint length); + int cmp_offset(uint row_offset); + void get_image(uchar *buff, uint length, CHARSET_INFO *cs) + { get_key_image(buff, length, itRAW); } + void set_image(const uchar *buff,uint length, CHARSET_INFO *cs) + { Field_bit::store((char *) buff, length, cs); } + uint get_key_image(uchar *buff, uint length, imagetype type); + void set_key_image(const uchar *buff, uint length) + { Field_bit::store((char*) buff, length, &my_charset_bin); } + void sort_string(uchar *buff, uint length) + { get_key_image(buff, length, itRAW); } + uint32 pack_length() const { return (uint32) (field_length + 7) / 8; } + uint32 pack_length_in_rec() const { return bytes_in_rec; } + uint pack_length_from_metadata(uint field_metadata); + uint row_pack_length() + { return (bytes_in_rec + ((bit_len > 0) ? 1 : 0)); } + int compatible_field_size(uint field_metadata); + void sql_type(String &str) const; + virtual uchar *pack(uchar *to, const uchar *from, + uint max_length, In_C_you_should_use_my_bool_instead() low_byte_first); + virtual const uchar *unpack(uchar *to, const uchar *from, + uint param_data, In_C_you_should_use_my_bool_instead() low_byte_first); + virtual void set_default(); + Field *new_key_field(MEM_ROOT *root, struct st_table *new_table, + uchar *new_ptr, uchar *new_null_ptr, + uint new_null_bit); + void set_bit_ptr(uchar *bit_ptr_arg, uchar bit_ofs_arg) + { + bit_ptr= bit_ptr_arg; + bit_ofs= bit_ofs_arg; + } + In_C_you_should_use_my_bool_instead() eq(Field *field) + { + return (Field::eq(field) && + field->type() == type() && + bit_ptr == ((Field_bit *)field)->bit_ptr && + bit_ofs == ((Field_bit *)field)->bit_ofs); + } + uint is_equal(Create_field *new_field); + void move_field_offset(my_ptrdiff_t ptr_diff) + { + Field::move_field_offset(ptr_diff); + bit_ptr= (uchar*) ((uchar*) (bit_ptr)+ptr_diff); + } + void hash(ulong *nr, ulong *nr2); +private: + virtual size_t do_last_null_byte() const; + int do_save_field_metadata(uchar *first_byte); +}; +class Field_bit_as_char: public Field_bit { +public: + Field_bit_as_char(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, + uchar null_bit_arg, + enum utype unireg_check_arg, const char *field_name_arg); + enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; } + uint size_of() const { return sizeof(*this); } + int store(const char *to, uint length, CHARSET_INFO *charset); + int store(double nr) { return Field_bit::store(nr); } + int store(longlong nr, In_C_you_should_use_my_bool_instead() unsigned_val) + { return Field_bit::store(nr, unsigned_val); } + void sql_type(String &str) const; +}; +class Create_field :public Sql_alloc +{ +public: + const char *field_name; + const char *change; + const char *after; + LEX_STRING comment; + Item *def; + enum enum_field_types sql_type; + ulong length; + uint32 char_length; + uint decimals, flags, pack_length, key_length; + Field::utype unireg_check; + TYPELIB *interval; + TYPELIB *save_interval; + List<String> interval_list; + CHARSET_INFO *charset; + Field::geometry_type geom_type; + Field *field; + uint8 row,col,sc_length,interval_id; + uint offset,pack_flag; + Create_field() :after(0) {} + Create_field(Field *field, Field *orig_field); + Create_field *clone(MEM_ROOT *mem_root) const + { return new (mem_root) Create_field(*this); } + void create_length_to_internal_length(void); + void init_for_tmp_table(enum_field_types sql_type_arg, + uint32 max_length, uint32 decimals, + In_C_you_should_use_my_bool_instead() maybe_null, In_C_you_should_use_my_bool_instead() is_unsigned); + In_C_you_should_use_my_bool_instead() init(THD *thd, char *field_name, enum_field_types type, char *length, + char *decimals, uint type_modifier, Item *default_value, + Item *on_update_value, LEX_STRING *comment, char *change, + List<String> *interval_list, CHARSET_INFO *cs, + uint uint_geom_type); +}; +class Send_field { + public: + const char *db_name; + const char *table_name,*org_table_name; + const char *col_name,*org_col_name; + ulong length; + uint charsetnr, flags, decimals; + enum_field_types type; + Send_field() {} +}; +class Copy_field :public Sql_alloc { + typedef void Copy_func(Copy_field*); + Copy_func *get_copy_func(Field *to, Field *from); +public: + uchar *from_ptr,*to_ptr; + uchar *from_null_ptr,*to_null_ptr; + my_bool *null_row; + uint from_bit,to_bit; + uint from_length,to_length; + Field *from_field,*to_field; + String tmp; + Copy_field() {} + ~Copy_field() {} + void set(Field *to,Field *from,In_C_you_should_use_my_bool_instead() save); + void set(uchar *to,Field *from); + void (*do_copy)(Copy_field *); + void (*do_copy2)(Copy_field *); +}; +Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length, + uchar *null_pos, uchar null_bit, + uint pack_flag, enum_field_types field_type, + CHARSET_INFO *cs, + Field::geometry_type geom_type, + Field::utype unireg_check, + TYPELIB *interval, const char *field_name); +uint pack_length_to_packflag(uint type); +enum_field_types get_blob_type_from_length(ulong length); +uint32 calc_pack_length(enum_field_types type,uint32 length); +int set_field_to_null(Field *field); +int set_field_to_null_with_conversions(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); +#include "protocol.h" +class i_string; +class THD; +typedef struct st_mysql_field MYSQL_FIELD; +typedef struct st_mysql_rows MYSQL_ROWS; +class Protocol +{ +protected: + THD *thd; + String *packet; + String *convert; + uint field_pos; + enum enum_field_types *field_types; + uint field_count; + In_C_you_should_use_my_bool_instead() net_store_data(const uchar *from, size_t length); + In_C_you_should_use_my_bool_instead() store_string_aux(const char *from, size_t length, + CHARSET_INFO *fromcs, CHARSET_INFO *tocs); +public: + Protocol() {} + Protocol(THD *thd_arg) { init(thd_arg); } + virtual ~Protocol() {} + void init(THD* thd_arg); + enum { SEND_NUM_ROWS= 1, SEND_DEFAULTS= 2, SEND_EOF= 4 }; + virtual In_C_you_should_use_my_bool_instead() send_fields(List<Item> *list, uint flags); + In_C_you_should_use_my_bool_instead() store(I_List<i_string> *str_list); + In_C_you_should_use_my_bool_instead() store(const char *from, CHARSET_INFO *cs); + String *storage_packet() { return packet; } + inline void free() { packet->free(); } + virtual In_C_you_should_use_my_bool_instead() write(); + inline In_C_you_should_use_my_bool_instead() store(int from) + { return store_long((longlong) from); } + inline In_C_you_should_use_my_bool_instead() store(uint32 from) + { return store_long((longlong) from); } + inline In_C_you_should_use_my_bool_instead() store(longlong from) + { return store_longlong((longlong) from, 0); } + inline In_C_you_should_use_my_bool_instead() store(ulonglong from) + { return store_longlong((longlong) from, 1); } + inline In_C_you_should_use_my_bool_instead() store(String *str) + { return store((char*) str->ptr(), str->length(), str->charset()); } + virtual In_C_you_should_use_my_bool_instead() prepare_for_send(List<Item> *item_list) + { + field_count=item_list->elements; + return 0; + } + virtual In_C_you_should_use_my_bool_instead() flush(); + virtual void end_partial_result_set(THD *thd); + virtual void prepare_for_resend()=0; + virtual In_C_you_should_use_my_bool_instead() store_null()=0; + virtual In_C_you_should_use_my_bool_instead() store_tiny(longlong from)=0; + virtual In_C_you_should_use_my_bool_instead() store_short(longlong from)=0; + virtual In_C_you_should_use_my_bool_instead() store_long(longlong from)=0; + virtual In_C_you_should_use_my_bool_instead() store_longlong(longlong from, In_C_you_should_use_my_bool_instead() unsigned_flag)=0; + virtual In_C_you_should_use_my_bool_instead() store_decimal(const my_decimal *)=0; + virtual In_C_you_should_use_my_bool_instead() store(const char *from, size_t length, CHARSET_INFO *cs)=0; + virtual In_C_you_should_use_my_bool_instead() store(const char *from, size_t length, + CHARSET_INFO *fromcs, CHARSET_INFO *tocs)=0; + virtual In_C_you_should_use_my_bool_instead() store(float from, uint32 decimals, String *buffer)=0; + virtual In_C_you_should_use_my_bool_instead() store(double from, uint32 decimals, String *buffer)=0; + virtual In_C_you_should_use_my_bool_instead() store(MYSQL_TIME *time)=0; + virtual In_C_you_should_use_my_bool_instead() store_date(MYSQL_TIME *time)=0; + virtual In_C_you_should_use_my_bool_instead() store_time(MYSQL_TIME *time)=0; + virtual In_C_you_should_use_my_bool_instead() store(Field *field)=0; + void remove_last_row() {} + enum enum_protocol_type + { + PROTOCOL_TEXT= 0, PROTOCOL_BINARY= 1 + }; + virtual enum enum_protocol_type type()= 0; +}; +class Protocol_text :public Protocol +{ +public: + Protocol_text() {} + Protocol_text(THD *thd_arg) :Protocol(thd_arg) {} + virtual void prepare_for_resend(); + virtual In_C_you_should_use_my_bool_instead() store_null(); + virtual In_C_you_should_use_my_bool_instead() store_tiny(longlong from); + virtual In_C_you_should_use_my_bool_instead() store_short(longlong from); + virtual In_C_you_should_use_my_bool_instead() store_long(longlong from); + virtual In_C_you_should_use_my_bool_instead() store_longlong(longlong from, In_C_you_should_use_my_bool_instead() unsigned_flag); + virtual In_C_you_should_use_my_bool_instead() store_decimal(const my_decimal *); + virtual In_C_you_should_use_my_bool_instead() store(const char *from, size_t length, CHARSET_INFO *cs); + virtual In_C_you_should_use_my_bool_instead() store(const char *from, size_t length, + CHARSET_INFO *fromcs, CHARSET_INFO *tocs); + virtual In_C_you_should_use_my_bool_instead() store(MYSQL_TIME *time); + virtual In_C_you_should_use_my_bool_instead() store_date(MYSQL_TIME *time); + virtual In_C_you_should_use_my_bool_instead() store_time(MYSQL_TIME *time); + virtual In_C_you_should_use_my_bool_instead() store(float nr, uint32 decimals, String *buffer); + virtual In_C_you_should_use_my_bool_instead() store(double from, uint32 decimals, String *buffer); + virtual In_C_you_should_use_my_bool_instead() store(Field *field); + virtual enum enum_protocol_type type() { return PROTOCOL_TEXT; }; +}; +class Protocol_binary :public Protocol +{ +private: + uint bit_fields; +public: + Protocol_binary() {} + Protocol_binary(THD *thd_arg) :Protocol(thd_arg) {} + virtual In_C_you_should_use_my_bool_instead() prepare_for_send(List<Item> *item_list); + virtual void prepare_for_resend(); + virtual In_C_you_should_use_my_bool_instead() store_null(); + virtual In_C_you_should_use_my_bool_instead() store_tiny(longlong from); + virtual In_C_you_should_use_my_bool_instead() store_short(longlong from); + virtual In_C_you_should_use_my_bool_instead() store_long(longlong from); + virtual In_C_you_should_use_my_bool_instead() store_longlong(longlong from, In_C_you_should_use_my_bool_instead() unsigned_flag); + virtual In_C_you_should_use_my_bool_instead() store_decimal(const my_decimal *); + virtual In_C_you_should_use_my_bool_instead() store(const char *from, size_t length, CHARSET_INFO *cs); + virtual In_C_you_should_use_my_bool_instead() store(const char *from, size_t length, + CHARSET_INFO *fromcs, CHARSET_INFO *tocs); + virtual In_C_you_should_use_my_bool_instead() store(MYSQL_TIME *time); + virtual In_C_you_should_use_my_bool_instead() store_date(MYSQL_TIME *time); + virtual In_C_you_should_use_my_bool_instead() store_time(MYSQL_TIME *time); + virtual In_C_you_should_use_my_bool_instead() store(float nr, uint32 decimals, String *buffer); + virtual In_C_you_should_use_my_bool_instead() store(double from, uint32 decimals, String *buffer); + virtual In_C_you_should_use_my_bool_instead() store(Field *field); + virtual enum enum_protocol_type type() { return PROTOCOL_BINARY; }; +}; +void send_warning(THD *thd, uint sql_errno, const char *err=0); +void net_send_error(THD *thd, uint sql_errno=0, const char *err=0); +void net_end_statement(THD *thd); +In_C_you_should_use_my_bool_instead() send_old_password_request(THD *thd); +uchar *net_store_data(uchar *to,const uchar *from, size_t length); +uchar *net_store_data(uchar *to,int32 from); +uchar *net_store_data(uchar *to,longlong from); +#include "sql_udf.h" +enum Item_udftype {UDFTYPE_FUNCTION=1,UDFTYPE_AGGREGATE}; +typedef void (*Udf_func_clear)(UDF_INIT *, uchar *, uchar *); +typedef void (*Udf_func_add)(UDF_INIT *, UDF_ARGS *, uchar *, uchar *); +typedef void (*Udf_func_deinit)(UDF_INIT*); +typedef my_bool (*Udf_func_init)(UDF_INIT *, UDF_ARGS *, char *); +typedef void (*Udf_func_any)(); +typedef double (*Udf_func_double)(UDF_INIT *, UDF_ARGS *, uchar *, uchar *); +typedef longlong (*Udf_func_longlong)(UDF_INIT *, UDF_ARGS *, uchar *, + uchar *); +typedef struct st_udf_func +{ + LEX_STRING name; + Item_result returns; + Item_udftype type; + char *dl; + void *dlhandle; + Udf_func_any func; + Udf_func_init func_init; + Udf_func_deinit func_deinit; + Udf_func_clear func_clear; + Udf_func_add func_add; + ulong usage_count; +} udf_func; +class Item_result_field; +class udf_handler :public Sql_alloc +{ + protected: + udf_func *u_d; + String *buffers; + UDF_ARGS f_args; + UDF_INIT initid; + char *num_buffer; + uchar error, is_null; + In_C_you_should_use_my_bool_instead() initialized; + Item **args; + public: + table_map used_tables_cache; + In_C_you_should_use_my_bool_instead() const_item_cache; + In_C_you_should_use_my_bool_instead() not_original; + udf_handler(udf_func *udf_arg) :u_d(udf_arg), buffers(0), error(0), + is_null(0), initialized(0), not_original(0) + {} + ~udf_handler(); + const char *name() const { return u_d ? u_d->name.str : "?"; } + Item_result result_type () const + { return u_d ? u_d->returns : STRING_RESULT;} + In_C_you_should_use_my_bool_instead() get_arguments(); + In_C_you_should_use_my_bool_instead() fix_fields(THD *thd, Item_result_field *item, + uint arg_count, Item **args); + void cleanup(); + double val(my_bool *null_value) + { + is_null= 0; + if (get_arguments()) + { + *null_value=1; + return 0.0; + } + Udf_func_double func= (Udf_func_double) u_d->func; + double tmp=func(&initid, &f_args, &is_null, &error); + if (is_null || error) + { + *null_value=1; + return 0.0; + } + *null_value=0; + return tmp; + } + longlong val_int(my_bool *null_value) + { + is_null= 0; + if (get_arguments()) + { + *null_value=1; + return 0LL; + } + Udf_func_longlong func= (Udf_func_longlong) u_d->func; + longlong tmp=func(&initid, &f_args, &is_null, &error); + if (is_null || error) + { + *null_value=1; + return 0LL; + } + *null_value=0; + return tmp; + } + my_decimal *val_decimal(my_bool *null_value, my_decimal *dec_buf); + void clear() + { + is_null= 0; + Udf_func_clear func= u_d->func_clear; + func(&initid, &is_null, &error); + } + void add(my_bool *null_value) + { + if (get_arguments()) + { + *null_value=1; + return; + } + Udf_func_add func= u_d->func_add; + func(&initid, &f_args, &is_null, &error); + *null_value= (my_bool) (is_null || error); + } + String *val_str(String *str,String *save_str); +}; +void udf_init(void),udf_free(void); +udf_func *find_udf(const char *name, uint len=0,In_C_you_should_use_my_bool_instead() mark_used=0); +void free_udf(udf_func *udf); +int mysql_create_function(THD *thd,udf_func *udf); +int mysql_drop_function(THD *thd,const LEX_STRING *name); +#include "sql_profile.h" +extern ST_FIELD_INFO query_profile_statistics_info[]; +int fill_query_profile_statistics_info(THD *thd, TABLE_LIST *tables, Item *cond); +int make_profile_table_for_show(THD *thd, ST_SCHEMA_TABLE *schema_table); +#include "sql_partition.h" +#pragma interface +typedef struct { + longlong list_value; + uint32 partition_id; +} LIST_PART_ENTRY; +typedef struct { + uint32 start_part; + uint32 end_part; +} part_id_range; +struct st_partition_iter; +In_C_you_should_use_my_bool_instead() is_partition_in_list(char *part_name, List<char> list_part_names); +char *are_partitions_in_table(partition_info *new_part_info, + partition_info *old_part_info); +In_C_you_should_use_my_bool_instead() check_reorganise_list(partition_info *new_part_info, + partition_info *old_part_info, + List<char> list_part_names); +handler *get_ha_partition(partition_info *part_info); +int get_parts_for_update(const uchar *old_data, uchar *new_data, + const uchar *rec0, partition_info *part_info, + uint32 *old_part_id, uint32 *new_part_id, + longlong *func_value); +int get_part_for_delete(const uchar *buf, const uchar *rec0, + partition_info *part_info, uint32 *part_id); +void prune_partition_set(const TABLE *table, part_id_range *part_spec); +In_C_you_should_use_my_bool_instead() check_partition_info(partition_info *part_info,handlerton **eng_type, + TABLE *table, handler *file, HA_CREATE_INFO *info); +void set_linear_hash_mask(partition_info *part_info, uint no_parts); +In_C_you_should_use_my_bool_instead() fix_partition_func(THD *thd, TABLE *table, In_C_you_should_use_my_bool_instead() create_table_ind); +char *generate_partition_syntax(partition_info *part_info, + uint *buf_length, In_C_you_should_use_my_bool_instead() use_sql_alloc, + In_C_you_should_use_my_bool_instead() show_partition_options); +In_C_you_should_use_my_bool_instead() partition_key_modified(TABLE *table, const MY_BITMAP *fields); +void get_partition_set(const TABLE *table, uchar *buf, const uint index, + const key_range *key_spec, + part_id_range *part_spec); +void get_full_part_id_from_key(const TABLE *table, uchar *buf, + KEY *key_info, + const key_range *key_spec, + part_id_range *part_spec); +In_C_you_should_use_my_bool_instead() mysql_unpack_partition(THD *thd, const char *part_buf, + uint part_info_len, + const char *part_state, uint part_state_len, + TABLE *table, In_C_you_should_use_my_bool_instead() is_create_table_ind, + handlerton *default_db_type, + In_C_you_should_use_my_bool_instead() *work_part_info_used); +void make_used_partitions_str(partition_info *part_info, String *parts_str); +uint32 get_list_array_idx_for_endpoint(partition_info *part_info, + In_C_you_should_use_my_bool_instead() left_endpoint, + In_C_you_should_use_my_bool_instead() include_endpoint); +uint32 get_partition_id_range_for_endpoint(partition_info *part_info, + In_C_you_should_use_my_bool_instead() left_endpoint, + In_C_you_should_use_my_bool_instead() include_endpoint); +In_C_you_should_use_my_bool_instead() fix_fields_part_func(THD *thd, Item* func_expr, TABLE *table, + In_C_you_should_use_my_bool_instead() is_sub_part, In_C_you_should_use_my_bool_instead() is_field_to_be_setup); +In_C_you_should_use_my_bool_instead() check_part_func_fields(Field **ptr, In_C_you_should_use_my_bool_instead() ok_with_charsets); +In_C_you_should_use_my_bool_instead() field_is_partition_charset(Field *field); +typedef uint32 (*partition_iter_func)(st_partition_iter* part_iter); +typedef struct st_partition_iter +{ + partition_iter_func get_next; + In_C_you_should_use_my_bool_instead() ret_null_part, ret_null_part_orig; + struct st_part_num_range + { + uint32 start; + uint32 cur; + uint32 end; + }; + struct st_field_value_range + { + longlong start; + longlong cur; + longlong end; + }; + union + { + struct st_part_num_range part_nums; + struct st_field_value_range field_vals; + }; + partition_info *part_info; +} PARTITION_ITERATOR; +typedef int (*get_partitions_in_range_iter)(partition_info *part_info, + In_C_you_should_use_my_bool_instead() is_subpart, + uchar *min_val, uchar *max_val, + uint flags, + PARTITION_ITERATOR *part_iter); +#include "partition_info.h" +#include "partition_element.h" +enum partition_type { + NOT_A_PARTITION= 0, + RANGE_PARTITION, + HASH_PARTITION, + LIST_PARTITION +}; +enum partition_state { + PART_NORMAL= 0, + PART_IS_DROPPED= 1, + PART_TO_BE_DROPPED= 2, + PART_TO_BE_ADDED= 3, + PART_TO_BE_REORGED= 4, + PART_REORGED_DROPPED= 5, + PART_CHANGED= 6, + PART_IS_CHANGED= 7, + PART_IS_ADDED= 8 +}; +typedef struct p_elem_val +{ + longlong value; + In_C_you_should_use_my_bool_instead() null_value; + In_C_you_should_use_my_bool_instead() unsigned_flag; +} part_elem_value; +struct st_ddl_log_memory_entry; +class partition_element :public Sql_alloc { +public: + List<partition_element> subpartitions; + List<part_elem_value> list_val_list; + ha_rows part_max_rows; + ha_rows part_min_rows; + longlong range_value; + char *partition_name; + char *tablespace_name; + struct st_ddl_log_memory_entry *log_entry; + char* part_comment; + char* data_file_name; + char* index_file_name; + handlerton *engine_type; + enum partition_state part_state; + uint16 nodegroup_id; + In_C_you_should_use_my_bool_instead() has_null_value; + In_C_you_should_use_my_bool_instead() signed_flag; + In_C_you_should_use_my_bool_instead() max_value; + partition_element() + : part_max_rows(0), part_min_rows(0), range_value(0), + partition_name(NULL), tablespace_name(NULL), + log_entry(NULL), part_comment(NULL), + data_file_name(NULL), index_file_name(NULL), + engine_type(NULL), part_state(PART_NORMAL), + nodegroup_id(65535), has_null_value((0)), + signed_flag((0)), max_value((0)) + { + } + partition_element(partition_element *part_elem) + : part_max_rows(part_elem->part_max_rows), + part_min_rows(part_elem->part_min_rows), + range_value(0), partition_name(NULL), + tablespace_name(part_elem->tablespace_name), + part_comment(part_elem->part_comment), + data_file_name(part_elem->data_file_name), + index_file_name(part_elem->index_file_name), + engine_type(part_elem->engine_type), + part_state(part_elem->part_state), + nodegroup_id(part_elem->nodegroup_id), + has_null_value((0)) + { + } + ~partition_element() {} +}; +class partition_info; +typedef int (*get_part_id_func)(partition_info *part_info, + uint32 *part_id, + longlong *func_value); +typedef uint32 (*get_subpart_id_func)(partition_info *part_info); +struct st_ddl_log_memory_entry; +class partition_info : public Sql_alloc +{ +public: + List<partition_element> partitions; + List<partition_element> temp_partitions; + List<char> part_field_list; + List<char> subpart_field_list; + get_part_id_func get_partition_id; + get_part_id_func get_part_partition_id; + get_subpart_id_func get_subpartition_id; + get_part_id_func get_partition_id_charset; + get_part_id_func get_part_partition_id_charset; + get_subpart_id_func get_subpartition_id_charset; + Field **part_field_array; + Field **subpart_field_array; + Field **part_charset_field_array; + Field **subpart_charset_field_array; + Field **full_part_field_array; + Field **full_part_charset_field_array; + MY_BITMAP full_part_field_set; + uchar **part_field_buffers; + uchar **subpart_field_buffers; + uchar **full_part_field_buffers; + uchar **restore_part_field_ptrs; + uchar **restore_subpart_field_ptrs; + uchar **restore_full_part_field_ptrs; + Item *part_expr; + Item *subpart_expr; + Item *item_free_list; + struct st_ddl_log_memory_entry *first_log_entry; + struct st_ddl_log_memory_entry *exec_log_entry; + struct st_ddl_log_memory_entry *frm_log_entry; + MY_BITMAP used_partitions; + union { + longlong *range_int_array; + LIST_PART_ENTRY *list_array; + }; + get_partitions_in_range_iter get_part_iter_for_interval; + get_partitions_in_range_iter get_subpart_iter_for_interval; + longlong err_value; + char* part_info_string; + char *part_func_string; + char *subpart_func_string; + const char *part_state; + partition_element *curr_part_elem; + partition_element *current_partition; + key_map all_fields_in_PF, all_fields_in_PPF, all_fields_in_SPF; + key_map some_fields_in_PF; + handlerton *default_engine_type; + Item_result part_result_type; + partition_type part_type; + partition_type subpart_type; + uint part_info_len; + uint part_state_len; + uint part_func_len; + uint subpart_func_len; + uint no_parts; + uint no_subparts; + uint count_curr_subparts; + uint part_error_code; + uint no_list_values; + uint no_part_fields; + uint no_subpart_fields; + uint no_full_part_fields; + uint has_null_part_id; + uint16 linear_hash_mask; + In_C_you_should_use_my_bool_instead() use_default_partitions; + In_C_you_should_use_my_bool_instead() use_default_no_partitions; + In_C_you_should_use_my_bool_instead() use_default_subpartitions; + In_C_you_should_use_my_bool_instead() use_default_no_subpartitions; + In_C_you_should_use_my_bool_instead() default_partitions_setup; + In_C_you_should_use_my_bool_instead() defined_max_value; + In_C_you_should_use_my_bool_instead() list_of_part_fields; + In_C_you_should_use_my_bool_instead() list_of_subpart_fields; + In_C_you_should_use_my_bool_instead() linear_hash_ind; + In_C_you_should_use_my_bool_instead() fixed; + In_C_you_should_use_my_bool_instead() is_auto_partitioned; + In_C_you_should_use_my_bool_instead() from_openfrm; + In_C_you_should_use_my_bool_instead() has_null_value; + partition_info() + : get_partition_id(NULL), get_part_partition_id(NULL), + get_subpartition_id(NULL), + part_field_array(NULL), subpart_field_array(NULL), + part_charset_field_array(NULL), + subpart_charset_field_array(NULL), + full_part_field_array(NULL), + full_part_charset_field_array(NULL), + part_field_buffers(NULL), subpart_field_buffers(NULL), + full_part_field_buffers(NULL), + restore_part_field_ptrs(NULL), restore_subpart_field_ptrs(NULL), + restore_full_part_field_ptrs(NULL), + part_expr(NULL), subpart_expr(NULL), item_free_list(NULL), + first_log_entry(NULL), exec_log_entry(NULL), frm_log_entry(NULL), + list_array(NULL), err_value(0), + part_info_string(NULL), + part_func_string(NULL), subpart_func_string(NULL), + part_state(NULL), + curr_part_elem(NULL), current_partition(NULL), + default_engine_type(NULL), + part_result_type(INT_RESULT), + part_type(NOT_A_PARTITION), subpart_type(NOT_A_PARTITION), + part_info_len(0), part_state_len(0), + part_func_len(0), subpart_func_len(0), + no_parts(0), no_subparts(0), + count_curr_subparts(0), part_error_code(0), + no_list_values(0), no_part_fields(0), no_subpart_fields(0), + no_full_part_fields(0), has_null_part_id(0), linear_hash_mask(0), + use_default_partitions((1)), use_default_no_partitions((1)), + use_default_subpartitions((1)), use_default_no_subpartitions((1)), + default_partitions_setup((0)), defined_max_value((0)), + list_of_part_fields((0)), list_of_subpart_fields((0)), + linear_hash_ind((0)), fixed((0)), + is_auto_partitioned((0)), from_openfrm((0)), + has_null_value((0)) + { + all_fields_in_PF.clear_all(); + all_fields_in_PPF.clear_all(); + all_fields_in_SPF.clear_all(); + some_fields_in_PF.clear_all(); + partitions.empty(); + temp_partitions.empty(); + part_field_list.empty(); + subpart_field_list.empty(); + } + ~partition_info() {} + partition_info *get_clone(); + In_C_you_should_use_my_bool_instead() is_sub_partitioned() + { + return (subpart_type == NOT_A_PARTITION ? (0) : (1)); + } + uint get_tot_partitions() + { + return no_parts * (is_sub_partitioned() ? no_subparts : 1); + } + In_C_you_should_use_my_bool_instead() set_up_defaults_for_partitioning(handler *file, HA_CREATE_INFO *info, + uint start_no); + char *has_unique_names(); + In_C_you_should_use_my_bool_instead() check_engine_mix(handlerton *engine_type, In_C_you_should_use_my_bool_instead() default_engine); + In_C_you_should_use_my_bool_instead() check_range_constants(); + In_C_you_should_use_my_bool_instead() check_list_constants(); + In_C_you_should_use_my_bool_instead() check_partition_info(THD *thd, handlerton **eng_type, + handler *file, HA_CREATE_INFO *info, + In_C_you_should_use_my_bool_instead() check_partition_function); + void print_no_partition_found(TABLE *table); + In_C_you_should_use_my_bool_instead() set_up_charset_field_preps(); +private: + static int list_part_cmp(const void* a, const void* b); + static int list_part_cmp_unsigned(const void* a, const void* b); + In_C_you_should_use_my_bool_instead() set_up_default_partitions(handler *file, HA_CREATE_INFO *info, + uint start_no); + In_C_you_should_use_my_bool_instead() set_up_default_subpartitions(handler *file, HA_CREATE_INFO *info); + char *create_default_partition_names(uint part_no, uint no_parts, + uint start_no); + char *create_subpartition_name(uint subpart_no, const char *part_name); + In_C_you_should_use_my_bool_instead() has_unique_name(partition_element *element); +}; +uint32 get_next_partition_id_range(struct st_partition_iter* part_iter); +In_C_you_should_use_my_bool_instead() check_partition_dirs(partition_info *part_info); +static inline void init_single_partition_iterator(uint32 part_id, + PARTITION_ITERATOR *part_iter) +{ + part_iter->part_nums.start= part_iter->part_nums.cur= part_id; + part_iter->part_nums.end= part_id+1; + part_iter->get_next= get_next_partition_id_range; +} +static inline +void init_all_partitions_iterator(partition_info *part_info, + PARTITION_ITERATOR *part_iter) +{ + part_iter->part_nums.start= part_iter->part_nums.cur= 0; + part_iter->part_nums.end= part_info->no_parts; + part_iter->get_next= get_next_partition_id_range; +} +class user_var_entry; +class Security_context; +enum enum_var_type +{ + OPT_DEFAULT= 0, OPT_SESSION, OPT_GLOBAL +}; +class sys_var; +#include "item.h" +class Protocol; +struct TABLE_LIST; +void item_init(void); +class Item_field; +class DTCollation { +public: + CHARSET_INFO *collation; + enum Derivation derivation; + uint repertoire; + void set_repertoire_from_charset(CHARSET_INFO *cs) + { + repertoire= cs->state & 4096 ? + 1 : 3; + } + DTCollation() + { + collation= &my_charset_bin; + derivation= DERIVATION_NONE; + repertoire= 3; + } + DTCollation(CHARSET_INFO *collation_arg, Derivation derivation_arg) + { + collation= collation_arg; + derivation= derivation_arg; + set_repertoire_from_charset(collation_arg); + } + void set(DTCollation &dt) + { + collation= dt.collation; + derivation= dt.derivation; + repertoire= dt.repertoire; + } + void set(CHARSET_INFO *collation_arg, Derivation derivation_arg) + { + collation= collation_arg; + derivation= derivation_arg; + set_repertoire_from_charset(collation_arg); + } + void set(CHARSET_INFO *collation_arg, + Derivation derivation_arg, + uint repertoire_arg) + { + collation= collation_arg; + derivation= derivation_arg; + repertoire= repertoire_arg; + } + void set(CHARSET_INFO *collation_arg) + { + collation= collation_arg; + set_repertoire_from_charset(collation_arg); + } + void set(Derivation derivation_arg) + { derivation= derivation_arg; } + In_C_you_should_use_my_bool_instead() aggregate(DTCollation &dt, uint flags= 0); + In_C_you_should_use_my_bool_instead() set(DTCollation &dt1, DTCollation &dt2, uint flags= 0) + { set(dt1); return aggregate(dt2, flags); } + const char *derivation_name() const + { + switch(derivation) + { + case DERIVATION_IGNORABLE: return "IGNORABLE"; + case DERIVATION_COERCIBLE: return "COERCIBLE"; + case DERIVATION_IMPLICIT: return "IMPLICIT"; + case DERIVATION_SYSCONST: return "SYSCONST"; + case DERIVATION_EXPLICIT: return "EXPLICIT"; + case DERIVATION_NONE: return "NONE"; + default: return "UNKNOWN"; + } + } +}; +struct Hybrid_type_traits; +struct Hybrid_type +{ + longlong integer; + double real; + my_decimal dec_buf[3]; + int used_dec_buf_no; + const Hybrid_type_traits *traits; + Hybrid_type() {} + Hybrid_type(const Hybrid_type &rhs) :traits(rhs.traits) {} +}; +struct Hybrid_type_traits +{ + virtual Item_result type() const { return REAL_RESULT; } + virtual void + fix_length_and_dec(Item *item, Item *arg) const; + virtual void set_zero(Hybrid_type *val) const { val->real= 0.0; } + virtual void add(Hybrid_type *val, Field *f) const + { val->real+= f->val_real(); } + virtual void div(Hybrid_type *val, ulonglong u) const + { val->real/= ((double) (ulonglong) (u)); } + virtual longlong val_int(Hybrid_type *val, In_C_you_should_use_my_bool_instead() unsigned_flag) const + { return (longlong) rint(val->real); } + virtual double val_real(Hybrid_type *val) const { return val->real; } + virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const; + virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const; + static const Hybrid_type_traits *instance(); + Hybrid_type_traits() {} + virtual ~Hybrid_type_traits() {} +}; +struct Hybrid_type_traits_decimal: public Hybrid_type_traits +{ + virtual Item_result type() const { return DECIMAL_RESULT; } + virtual void + fix_length_and_dec(Item *arg, Item *item) const; + virtual void set_zero(Hybrid_type *val) const; + virtual void add(Hybrid_type *val, Field *f) const; + virtual void div(Hybrid_type *val, ulonglong u) const; + virtual longlong val_int(Hybrid_type *val, In_C_you_should_use_my_bool_instead() unsigned_flag) const; + virtual double val_real(Hybrid_type *val) const; + virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const + { return &val->dec_buf[val->used_dec_buf_no]; } + virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const; + static const Hybrid_type_traits_decimal *instance(); + Hybrid_type_traits_decimal() {}; +}; +struct Hybrid_type_traits_integer: public Hybrid_type_traits +{ + virtual Item_result type() const { return INT_RESULT; } + virtual void + fix_length_and_dec(Item *arg, Item *item) const; + virtual void set_zero(Hybrid_type *val) const + { val->integer= 0; } + virtual void add(Hybrid_type *val, Field *f) const + { val->integer+= f->val_int(); } + virtual void div(Hybrid_type *val, ulonglong u) const + { val->integer/= (longlong) u; } + virtual longlong val_int(Hybrid_type *val, In_C_you_should_use_my_bool_instead() unsigned_flag) const + { return val->integer; } + virtual double val_real(Hybrid_type *val) const + { return (double) val->integer; } + virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const + { + int2my_decimal(30, val->integer, 0, &val->dec_buf[2]); + return &val->dec_buf[2]; + } + virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const + { buf->set(val->integer, &my_charset_bin); return buf;} + static const Hybrid_type_traits_integer *instance(); + Hybrid_type_traits_integer() {}; +}; +void dummy_error_processor(THD *thd, void *data); +void view_error_processor(THD *thd, void *data); +struct Name_resolution_context: Sql_alloc +{ + Name_resolution_context *outer_context; + TABLE_LIST *table_list; + TABLE_LIST *first_name_resolution_table; + TABLE_LIST *last_name_resolution_table; + st_select_lex *select_lex; + void (*error_processor)(THD *, void *); + void *error_processor_data; + In_C_you_should_use_my_bool_instead() resolve_in_select_list; + Security_context *security_ctx; + Name_resolution_context() + :outer_context(0), table_list(0), select_lex(0), + error_processor_data(0), + security_ctx(0) + {} + void init() + { + resolve_in_select_list= (0); + error_processor= &dummy_error_processor; + first_name_resolution_table= NULL; + last_name_resolution_table= NULL; + } + void resolve_in_table_list_only(TABLE_LIST *tables) + { + table_list= first_name_resolution_table= tables; + resolve_in_select_list= (0); + } + void process_error(THD *thd) + { + (*error_processor)(thd, error_processor_data); + } +}; +class Name_resolution_context_state +{ +private: + TABLE_LIST *save_table_list; + TABLE_LIST *save_first_name_resolution_table; + TABLE_LIST *save_next_name_resolution_table; + In_C_you_should_use_my_bool_instead() save_resolve_in_select_list; + TABLE_LIST *save_next_local; +public: + Name_resolution_context_state() {} +public: + void save_state(Name_resolution_context *context, TABLE_LIST *table_list) + { + save_table_list= context->table_list; + save_first_name_resolution_table= context->first_name_resolution_table; + save_resolve_in_select_list= context->resolve_in_select_list; + save_next_local= table_list->next_local; + save_next_name_resolution_table= table_list->next_name_resolution_table; + } + void restore_state(Name_resolution_context *context, TABLE_LIST *table_list) + { + table_list->next_local= save_next_local; + table_list->next_name_resolution_table= save_next_name_resolution_table; + context->table_list= save_table_list; + context->first_name_resolution_table= save_first_name_resolution_table; + context->resolve_in_select_list= save_resolve_in_select_list; + } + TABLE_LIST *get_first_name_resolution_table() + { + return save_first_name_resolution_table; + } +}; +typedef enum monotonicity_info +{ + NON_MONOTONIC, + MONOTONIC_INCREASING, + MONOTONIC_STRICT_INCREASING +} enum_monotonicity_info; +class sp_rcontext; +class Settable_routine_parameter +{ +public: + Settable_routine_parameter() {} + virtual ~Settable_routine_parameter() {} + virtual void set_required_privilege(In_C_you_should_use_my_bool_instead() rw) {}; + virtual In_C_you_should_use_my_bool_instead() set_value(THD *thd, sp_rcontext *ctx, Item **it)= 0; +}; +typedef In_C_you_should_use_my_bool_instead() (Item::*Item_processor) (uchar *arg); +typedef In_C_you_should_use_my_bool_instead() (Item::*Item_analyzer) (uchar **argp); +typedef Item* (Item::*Item_transformer) (uchar *arg); +typedef void (*Cond_traverser) (const Item *item, void *arg); +class Item { + Item(const Item &); + void operator=(Item &); +public: + static void *operator new(size_t size) + { return sql_alloc(size); } + static void *operator new(size_t size, MEM_ROOT *mem_root) + { return alloc_root(mem_root, size); } + static void operator delete(void *ptr,size_t size) { ; } + static void operator delete(void *ptr, MEM_ROOT *mem_root) {} + enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM, STRING_ITEM, + INT_ITEM, REAL_ITEM, NULL_ITEM, VARBIN_ITEM, + COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM, + PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM, + FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM, + SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM, TYPE_HOLDER, + PARAM_ITEM, TRIGGER_FIELD_ITEM, DECIMAL_ITEM, + XPATH_NODESET, XPATH_NODESET_CMP, + VIEW_FIXER_ITEM}; + enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE }; + enum traverse_order { POSTFIX, PREFIX }; + uint rsize; + String str_value; + char * name; + char * orig_name; + Item *next; + uint32 max_length; + uint name_length; + int8 marker; + uint8 decimals; + my_bool maybe_null; + my_bool null_value; + my_bool unsigned_flag; + my_bool with_sum_func; + my_bool fixed; + my_bool is_autogenerated_name; + DTCollation collation; + my_bool with_subselect; + Item_result cmp_context; + Item(); + Item(THD *thd, Item *item); + virtual ~Item() + { + } + void set_name(const char *str, uint length, CHARSET_INFO *cs); + void rename(char *new_name); + void init_make_field(Send_field *tmp_field,enum enum_field_types type); + virtual void cleanup(); + virtual void make_field(Send_field *field); + Field *make_string_field(TABLE *table); + virtual In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + inline void quick_fix_field() { fixed= 1; } + int save_in_field_no_warnings(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + virtual int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + virtual void save_org_in_field(Field *field) + { (void) save_in_field(field, 1); } + virtual int save_safe_in_field(Field *field) + { return save_in_field(field, 1); } + virtual In_C_you_should_use_my_bool_instead() send(Protocol *protocol, String *str); + virtual In_C_you_should_use_my_bool_instead() eq(const Item *, In_C_you_should_use_my_bool_instead() binary_cmp) const; + virtual Item_result result_type() const { return REAL_RESULT; } + virtual Item_result cast_to_int_type() const { return result_type(); } + virtual enum_field_types string_field_type() const; + virtual enum_field_types field_type() const; + virtual enum Type type() const =0; + virtual enum_monotonicity_info get_monotonicity_info() const + { return NON_MONOTONIC; } + virtual longlong val_int_endpoint(In_C_you_should_use_my_bool_instead() left_endp, In_C_you_should_use_my_bool_instead() *incl_endp) + { assert(0); return 0; } + virtual double val_real()=0; + virtual longlong val_int()=0; + inline ulonglong val_uint() { return (ulonglong) val_int(); } + virtual String *val_str(String *str)=0; + virtual my_decimal *val_decimal(my_decimal *decimal_buffer)= 0; + virtual In_C_you_should_use_my_bool_instead() val_bool(); + virtual String *val_nodeset(String*) { return 0; } + String *val_string_from_real(String *str); + String *val_string_from_int(String *str); + String *val_string_from_decimal(String *str); + my_decimal *val_decimal_from_real(my_decimal *decimal_value); + my_decimal *val_decimal_from_int(my_decimal *decimal_value); + my_decimal *val_decimal_from_string(my_decimal *decimal_value); + my_decimal *val_decimal_from_date(my_decimal *decimal_value); + my_decimal *val_decimal_from_time(my_decimal *decimal_value); + longlong val_int_from_decimal(); + double val_real_from_decimal(); + int save_time_in_field(Field *field); + int save_date_in_field(Field *field); + int save_str_value_in_field(Field *field, String *result); + virtual Field *get_tmp_table_field() { return 0; } + virtual Field *tmp_table_field(TABLE *t_arg) { return 0; } + virtual const char *full_name() const { return name ? name : "???"; } + virtual double val_result() { return val_real(); } + virtual longlong val_int_result() { return val_int(); } + virtual String *str_result(String* tmp) { return val_str(tmp); } + virtual my_decimal *val_decimal_result(my_decimal *val) + { return val_decimal(val); } + virtual In_C_you_should_use_my_bool_instead() val_bool_result() { return val_bool(); } + virtual table_map used_tables() const { return (table_map) 0L; } + virtual table_map not_null_tables() const { return used_tables(); } + virtual In_C_you_should_use_my_bool_instead() basic_const_item() const { return 0; } + virtual Item *clone_item() { return 0; } + virtual cond_result eq_cmp_result() const { return COND_OK; } + inline uint float_length(uint decimals_par) const + { return decimals != 31 ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;} + virtual uint decimal_precision() const; + inline int decimal_int_part() const + { return my_decimal_int_part(decimal_precision(), decimals); } + virtual In_C_you_should_use_my_bool_instead() const_item() const { return used_tables() == 0; } + virtual In_C_you_should_use_my_bool_instead() const_during_execution() const + { return (used_tables() & ~(((table_map) 1) << (sizeof(table_map)*8-3))) == 0; } + virtual inline void print(String *str, enum_query_type query_type) + { + str->append(full_name()); + } + void print_item_w_name(String *, enum_query_type query_type); + virtual void update_used_tables() {} + virtual void split_sum_func(THD *thd, Item **ref_pointer_array, + List<Item> &fields) {} + void split_sum_func2(THD *thd, Item **ref_pointer_array, List<Item> &fields, + Item **ref, In_C_you_should_use_my_bool_instead() skip_registered); + virtual In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + virtual In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); + virtual In_C_you_should_use_my_bool_instead() get_date_result(MYSQL_TIME *ltime,uint fuzzydate) + { return get_date(ltime,fuzzydate); } + virtual In_C_you_should_use_my_bool_instead() is_null() { return 0; } + virtual void update_null_value () { (void) val_int(); } + virtual void top_level_item() {} + virtual void set_result_field(Field *field) {} + virtual In_C_you_should_use_my_bool_instead() is_result_field() { return 0; } + virtual In_C_you_should_use_my_bool_instead() is_bool_func() { return 0; } + virtual void save_in_result_field(In_C_you_should_use_my_bool_instead() no_conversions) {} + virtual void no_rows_in_result() {} + virtual Item *copy_or_same(THD *thd) { return this; } + virtual Item *copy_andor_structure(THD *thd) { return this; } + virtual Item *real_item() { return this; } + virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); } + static CHARSET_INFO *default_charset(); + virtual CHARSET_INFO *compare_collation() { return NULL; } + virtual In_C_you_should_use_my_bool_instead() walk(Item_processor processor, In_C_you_should_use_my_bool_instead() walk_subquery, uchar *arg) + { + return (this->*processor)(arg); + } + virtual Item* transform(Item_transformer transformer, uchar *arg); + virtual Item* compile(Item_analyzer analyzer, uchar **arg_p, + Item_transformer transformer, uchar *arg_t) + { + if ((this->*analyzer) (arg_p)) + return ((this->*transformer) (arg_t)); + return 0; + } + virtual void traverse_cond(Cond_traverser traverser, + void *arg, traverse_order order) + { + (*traverser)(this, arg); + } + virtual In_C_you_should_use_my_bool_instead() remove_dependence_processor(uchar * arg) { return 0; } + virtual In_C_you_should_use_my_bool_instead() remove_fixed(uchar * arg) { fixed= 0; return 0; } + virtual In_C_you_should_use_my_bool_instead() cleanup_processor(uchar *arg); + virtual In_C_you_should_use_my_bool_instead() collect_item_field_processor(uchar * arg) { return 0; } + virtual In_C_you_should_use_my_bool_instead() find_item_in_field_list_processor(uchar *arg) { return 0; } + virtual In_C_you_should_use_my_bool_instead() change_context_processor(uchar *context) { return 0; } + virtual In_C_you_should_use_my_bool_instead() reset_query_id_processor(uchar *query_id_arg) { return 0; } + virtual In_C_you_should_use_my_bool_instead() is_expensive_processor(uchar *arg) { return 0; } + virtual In_C_you_should_use_my_bool_instead() register_field_in_read_map(uchar *arg) { return 0; } + virtual In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *bool_arg) { return (1);} + virtual In_C_you_should_use_my_bool_instead() subst_argument_checker(uchar **arg) + { + if (*arg) + *arg= NULL; + return (1); + } + virtual Item *equal_fields_propagator(uchar * arg) { return this; } + virtual In_C_you_should_use_my_bool_instead() set_no_const_sub(uchar *arg) { return (0); } + virtual Item *replace_equal_field(uchar * arg) { return this; } + virtual Item *this_item() { return this; } + virtual const Item *this_item() const { return this; } + virtual Item **this_item_addr(THD *thd, Item **addr_arg) { return addr_arg; } + virtual uint cols() { return 1; } + virtual Item* element_index(uint i) { return this; } + virtual Item** addr(uint i) { return 0; } + virtual In_C_you_should_use_my_bool_instead() check_cols(uint c); + virtual In_C_you_should_use_my_bool_instead() null_inside() { return 0; } + virtual void bring_value() {} + Field *tmp_table_field_from_field_type(TABLE *table, In_C_you_should_use_my_bool_instead() fixed_length); + virtual Item_field *filed_for_view_update() { return 0; } + virtual Item *neg_transformer(THD *thd) { return NULL; } + virtual Item *update_value_transformer(uchar *select_arg) { return this; } + virtual Item *safe_charset_converter(CHARSET_INFO *tocs); + void delete_self() + { + cleanup(); + delete this; + } + virtual In_C_you_should_use_my_bool_instead() is_splocal() { return 0; } + virtual Settable_routine_parameter *get_settable_routine_parameter() + { + return 0; + } + virtual In_C_you_should_use_my_bool_instead() result_as_longlong() { return (0); } + In_C_you_should_use_my_bool_instead() is_datetime(); + virtual Field::geometry_type get_geometry_type() const + { return Field::GEOM_GEOMETRY; }; + String *check_well_formed_result(String *str, In_C_you_should_use_my_bool_instead() send_error= 0); + In_C_you_should_use_my_bool_instead() eq_by_collation(Item *item, In_C_you_should_use_my_bool_instead() binary_cmp, CHARSET_INFO *cs); +}; +class sp_head; +class Item_basic_constant :public Item +{ +public: + void cleanup() + { + if (orig_name) + name= orig_name; + } +}; +class Item_sp_variable :public Item +{ +protected: + THD *m_thd; +public: + LEX_STRING m_name; +public: + sp_head *m_sp; +public: + Item_sp_variable(char *sp_var_name_str, uint sp_var_name_length); +public: + In_C_you_should_use_my_bool_instead() fix_fields(THD *thd, Item **); + double val_real(); + longlong val_int(); + String *val_str(String *sp); + my_decimal *val_decimal(my_decimal *decimal_value); + In_C_you_should_use_my_bool_instead() is_null(); +public: + inline void make_field(Send_field *field); + inline In_C_you_should_use_my_bool_instead() const_item() const; + inline int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + inline In_C_you_should_use_my_bool_instead() send(Protocol *protocol, String *str); +}; +inline void Item_sp_variable::make_field(Send_field *field) +{ + Item *it= this_item(); + if (name) + it->set_name(name, (uint) strlen(name), system_charset_info); + else + it->set_name(m_name.str, m_name.length, system_charset_info); + it->make_field(field); +} +inline In_C_you_should_use_my_bool_instead() Item_sp_variable::const_item() const +{ + return (1); +} +inline int Item_sp_variable::save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions) +{ + return this_item()->save_in_field(field, no_conversions); +} +inline In_C_you_should_use_my_bool_instead() Item_sp_variable::send(Protocol *protocol, String *str) +{ + return this_item()->send(protocol, str); +} +class Item_splocal :public Item_sp_variable, + private Settable_routine_parameter +{ + uint m_var_idx; + Type m_type; + Item_result m_result_type; + enum_field_types m_field_type; +public: + uint pos_in_query; + uint len_in_query; + Item_splocal(const LEX_STRING &sp_var_name, uint sp_var_idx, + enum_field_types sp_var_type, + uint pos_in_q= 0, uint len_in_q= 0); + In_C_you_should_use_my_bool_instead() is_splocal() { return 1; } + Item *this_item(); + const Item *this_item() const; + Item **this_item_addr(THD *thd, Item **); + virtual void print(String *str, enum_query_type query_type); +public: + inline const LEX_STRING *my_name() const; + inline uint get_var_idx() const; + inline enum Type type() const; + inline Item_result result_type() const; + inline enum_field_types field_type() const { return m_field_type; } +private: + In_C_you_should_use_my_bool_instead() set_value(THD *thd, sp_rcontext *ctx, Item **it); +public: + Settable_routine_parameter *get_settable_routine_parameter() + { + return this; + } +}; +inline const LEX_STRING *Item_splocal::my_name() const +{ + return &m_name; +} +inline uint Item_splocal::get_var_idx() const +{ + return m_var_idx; +} +inline enum Item::Type Item_splocal::type() const +{ + return m_type; +} +inline Item_result Item_splocal::result_type() const +{ + return m_result_type; +} +class Item_case_expr :public Item_sp_variable +{ +public: + Item_case_expr(uint case_expr_id); +public: + Item *this_item(); + const Item *this_item() const; + Item **this_item_addr(THD *thd, Item **); + inline enum Type type() const; + inline Item_result result_type() const; +public: + virtual void print(String *str, enum_query_type query_type); +private: + uint m_case_expr_id; +}; +inline enum Item::Type Item_case_expr::type() const +{ + return this_item()->type(); +} +inline Item_result Item_case_expr::result_type() const +{ + return this_item()->result_type(); +} +class Item_name_const : public Item +{ + Item *value_item; + Item *name_item; + In_C_you_should_use_my_bool_instead() valid_args; +public: + Item_name_const(Item *name_arg, Item *val); + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + enum Type type() const; + double val_real(); + longlong val_int(); + String *val_str(String *sp); + my_decimal *val_decimal(my_decimal *); + In_C_you_should_use_my_bool_instead() is_null(); + virtual void print(String *str, enum_query_type query_type); + Item_result result_type() const + { + return value_item->result_type(); + } + In_C_you_should_use_my_bool_instead() const_item() const + { + return (1); + } + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions) + { + return value_item->save_in_field(field, no_conversions); + } + In_C_you_should_use_my_bool_instead() send(Protocol *protocol, String *str) + { + return value_item->send(protocol, str); + } +}; +In_C_you_should_use_my_bool_instead() agg_item_collations(DTCollation &c, const char *name, + Item **items, uint nitems, uint flags, int item_sep); +In_C_you_should_use_my_bool_instead() agg_item_collations_for_comparison(DTCollation &c, const char *name, + Item **items, uint nitems, uint flags); +In_C_you_should_use_my_bool_instead() agg_item_charsets(DTCollation &c, const char *name, + Item **items, uint nitems, uint flags, int item_sep); +class Item_num: public Item_basic_constant +{ +public: + Item_num() {} + virtual Item_num *neg()= 0; + Item *safe_charset_converter(CHARSET_INFO *tocs); + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *int_arg) { return (0);} +}; +class st_select_lex; +class Item_ident :public Item +{ +protected: + const char *orig_db_name; + const char *orig_table_name; + const char *orig_field_name; +public: + Name_resolution_context *context; + const char *db_name; + const char *table_name; + const char *field_name; + In_C_you_should_use_my_bool_instead() alias_name_used; + uint cached_field_index; + TABLE_LIST *cached_table; + st_select_lex *depended_from; + Item_ident(Name_resolution_context *context_arg, + const char *db_name_arg, const char *table_name_arg, + const char *field_name_arg); + Item_ident(THD *thd, Item_ident *item); + const char *full_name() const; + void cleanup(); + In_C_you_should_use_my_bool_instead() remove_dependence_processor(uchar * arg); + virtual void print(String *str, enum_query_type query_type); + virtual In_C_you_should_use_my_bool_instead() change_context_processor(uchar *cntx) + { context= (Name_resolution_context *)cntx; return (0); } + friend In_C_you_should_use_my_bool_instead() insert_fields(THD *thd, Name_resolution_context *context, + const char *db_name, + const char *table_name, List_iterator<Item> *it, + In_C_you_should_use_my_bool_instead() any_privileges); +}; +class Item_ident_for_show :public Item +{ +public: + Field *field; + const char *db_name; + const char *table_name; + Item_ident_for_show(Field *par_field, const char *db_arg, + const char *table_name_arg) + :field(par_field), db_name(db_arg), table_name(table_name_arg) + {} + enum Type type() const { return FIELD_ITEM; } + double val_real() { return field->val_real(); } + longlong val_int() { return field->val_int(); } + String *val_str(String *str) { return field->val_str(str); } + my_decimal *val_decimal(my_decimal *dec) { return field->val_decimal(dec); } + void make_field(Send_field *tmp_field); +}; +class Item_equal; +class COND_EQUAL; +class Item_field :public Item_ident +{ +protected: + void set_field(Field *field); +public: + Field *field,*result_field; + Item_equal *item_equal; + In_C_you_should_use_my_bool_instead() no_const_subst; + uint have_privileges; + In_C_you_should_use_my_bool_instead() any_privileges; + Item_field(Name_resolution_context *context_arg, + const char *db_arg,const char *table_name_arg, + const char *field_name_arg); + Item_field(THD *thd, Item_field *item); + Item_field(THD *thd, Name_resolution_context *context_arg, Field *field); + Item_field(Field *field); + enum Type type() const { return FIELD_ITEM; } + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + double val_real(); + longlong val_int(); + my_decimal *val_decimal(my_decimal *); + String *val_str(String*); + double val_result(); + longlong val_int_result(); + String *str_result(String* tmp); + my_decimal *val_decimal_result(my_decimal *); + In_C_you_should_use_my_bool_instead() val_bool_result(); + In_C_you_should_use_my_bool_instead() send(Protocol *protocol, String *str_arg); + void reset_field(Field *f); + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + void make_field(Send_field *tmp_field); + int save_in_field(Field *field,In_C_you_should_use_my_bool_instead() no_conversions); + void save_org_in_field(Field *field); + table_map used_tables() const; + enum Item_result result_type () const + { + return field->result_type(); + } + Item_result cast_to_int_type() const + { + return field->cast_to_int_type(); + } + enum_field_types field_type() const + { + return field->type(); + } + enum_monotonicity_info get_monotonicity_info() const + { + return MONOTONIC_STRICT_INCREASING; + } + longlong val_int_endpoint(In_C_you_should_use_my_bool_instead() left_endp, In_C_you_should_use_my_bool_instead() *incl_endp); + Field *get_tmp_table_field() { return result_field; } + Field *tmp_table_field(TABLE *t_arg) { return result_field; } + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + In_C_you_should_use_my_bool_instead() get_date_result(MYSQL_TIME *ltime,uint fuzzydate); + In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *ltime); + In_C_you_should_use_my_bool_instead() is_null() { return field->is_null(); } + void update_null_value(); + Item *get_tmp_table_item(THD *thd); + In_C_you_should_use_my_bool_instead() collect_item_field_processor(uchar * arg); + In_C_you_should_use_my_bool_instead() find_item_in_field_list_processor(uchar *arg); + In_C_you_should_use_my_bool_instead() register_field_in_read_map(uchar *arg); + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *int_arg) {return (0);} + void cleanup(); + In_C_you_should_use_my_bool_instead() result_as_longlong() + { + return field->can_be_compared_as_longlong(); + } + Item_equal *find_item_equal(COND_EQUAL *cond_equal); + In_C_you_should_use_my_bool_instead() subst_argument_checker(uchar **arg); + Item *equal_fields_propagator(uchar *arg); + In_C_you_should_use_my_bool_instead() set_no_const_sub(uchar *arg); + Item *replace_equal_field(uchar *arg); + inline uint32 max_disp_length() { return field->max_display_length(); } + Item_field *filed_for_view_update() { return this; } + Item *safe_charset_converter(CHARSET_INFO *tocs); + int fix_outer_field(THD *thd, Field **field, Item **reference); + virtual Item *update_value_transformer(uchar *select_arg); + virtual void print(String *str, enum_query_type query_type); + Field::geometry_type get_geometry_type() const + { + assert(field_type() == MYSQL_TYPE_GEOMETRY); + return field->get_geometry_type(); + } + friend class Item_default_value; + friend class Item_insert_value; + friend class st_select_lex_unit; +}; +class Item_null :public Item_basic_constant +{ +public: + Item_null(char *name_par=0) + { + maybe_null= null_value= (1); + max_length= 0; + name= name_par ? name_par : (char*) "NULL"; + fixed= 1; + collation.set(&my_charset_bin, DERIVATION_IGNORABLE); + } + enum Type type() const { return NULL_ITEM; } + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + double val_real(); + longlong val_int(); + String *val_str(String *str); + my_decimal *val_decimal(my_decimal *); + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + int save_safe_in_field(Field *field); + In_C_you_should_use_my_bool_instead() send(Protocol *protocol, String *str); + enum Item_result result_type () const { return STRING_RESULT; } + enum_field_types field_type() const { return MYSQL_TYPE_NULL; } + In_C_you_should_use_my_bool_instead() basic_const_item() const { return 1; } + Item *clone_item() { return new Item_null(name); } + In_C_you_should_use_my_bool_instead() is_null() { return 1; } + virtual inline void print(String *str, enum_query_type query_type) + { + str->append(("NULL"), ((size_t) (sizeof("NULL") - 1))); + } + Item *safe_charset_converter(CHARSET_INFO *tocs); + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *int_arg) {return (0);} +}; +class Item_null_result :public Item_null +{ +public: + Field *result_field; + Item_null_result() : Item_null(), result_field(0) {} + In_C_you_should_use_my_bool_instead() is_result_field() { return result_field != 0; } + void save_in_result_field(In_C_you_should_use_my_bool_instead() no_conversions) + { + save_in_field(result_field, no_conversions); + } + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *int_arg) {return (1);} +}; +class Item_param :public Item +{ + char cnvbuf[(255*3 +1)]; + String cnvstr; + Item *cnvitem; +public: + enum enum_item_param_state + { + NO_VALUE, NULL_VALUE, INT_VALUE, REAL_VALUE, + STRING_VALUE, TIME_VALUE, LONG_DATA_VALUE, + DECIMAL_VALUE + } state; + String str_value_ptr; + my_decimal decimal_value; + union + { + longlong integer; + double real; + struct CONVERSION_INFO + { + CHARSET_INFO *character_set_client; + CHARSET_INFO *character_set_of_placeholder; + CHARSET_INFO *final_character_set_of_str_value; + } cs_info; + MYSQL_TIME time; + } value; + enum Item_result item_result_type; + enum Type item_type; + enum enum_field_types param_type; + uint pos_in_query; + Item_param(uint pos_in_query_arg); + enum Item_result result_type () const { return item_result_type; } + enum Type type() const { return item_type; } + enum_field_types field_type() const { return param_type; } + double val_real(); + longlong val_int(); + my_decimal *val_decimal(my_decimal*); + String *val_str(String*); + In_C_you_should_use_my_bool_instead() get_time(MYSQL_TIME *tm); + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *tm, uint fuzzydate); + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + void set_null(); + void set_int(longlong i, uint32 max_length_arg); + void set_double(double i); + void set_decimal(const char *str, ulong length); + In_C_you_should_use_my_bool_instead() set_str(const char *str, ulong length); + In_C_you_should_use_my_bool_instead() set_longdata(const char *str, ulong length); + void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg); + In_C_you_should_use_my_bool_instead() set_from_user_var(THD *thd, const user_var_entry *entry); + void reset(); + void (*set_param_func)(Item_param *param, uchar **pos, ulong len); + const String *query_val_str(String *str) const; + In_C_you_should_use_my_bool_instead() convert_str_value(THD *thd); + virtual table_map used_tables() const + { return state != NO_VALUE ? (table_map)0 : (((table_map) 1) << (sizeof(table_map)*8-3)); } + virtual void print(String *str, enum_query_type query_type); + In_C_you_should_use_my_bool_instead() is_null() + { assert(state != NO_VALUE); return state == NULL_VALUE; } + In_C_you_should_use_my_bool_instead() basic_const_item() const; + Item *safe_charset_converter(CHARSET_INFO *tocs); + Item *clone_item(); + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + In_C_you_should_use_my_bool_instead() limit_clause_param; + void set_param_type_and_swap_value(Item_param *from); +}; +class Item_int :public Item_num +{ +public: + longlong value; + Item_int(int32 i,uint length= 11) + :value((longlong) i) + { max_length=length; fixed= 1; } + Item_int(longlong i,uint length= 21) + :value(i) + { max_length=length; fixed= 1; } + Item_int(ulonglong i, uint length= 21) + :value((longlong)i) + { max_length=length; fixed= 1; unsigned_flag= 1; } + Item_int(const char *str_arg,longlong i,uint length) :value(i) + { max_length=length; name=(char*) str_arg; fixed= 1; } + Item_int(const char *str_arg, uint length=64); + enum Type type() const { return INT_ITEM; } + enum Item_result result_type () const { return INT_RESULT; } + enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; } + longlong val_int() { assert(fixed == 1); return value; } + double val_real() { assert(fixed == 1); return (double) value; } + my_decimal *val_decimal(my_decimal *); + String *val_str(String*); + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + In_C_you_should_use_my_bool_instead() basic_const_item() const { return 1; } + Item *clone_item() { return new Item_int(name,value,max_length); } + virtual void print(String *str, enum_query_type query_type); + Item_num *neg() { value= -value; return this; } + uint decimal_precision() const + { return (uint)(max_length - ((value < 0) ? 1 : 0)); } + In_C_you_should_use_my_bool_instead() eq(const Item *, In_C_you_should_use_my_bool_instead() binary_cmp) const; + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *bool_arg) { return (0);} +}; +class Item_uint :public Item_int +{ +public: + Item_uint(const char *str_arg, uint length); + Item_uint(ulonglong i) :Item_int((ulonglong) i, 10) {} + Item_uint(const char *str_arg, longlong i, uint length); + double val_real() + { assert(fixed == 1); return ((double) (ulonglong) ((ulonglong)value)); } + String *val_str(String*); + Item *clone_item() { return new Item_uint(name, value, max_length); } + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + virtual void print(String *str, enum_query_type query_type); + Item_num *neg (); + uint decimal_precision() const { return max_length; } + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *bool_arg) { return (0);} +}; +class Item_decimal :public Item_num +{ +protected: + my_decimal decimal_value; +public: + Item_decimal(const char *str_arg, uint length, CHARSET_INFO *charset); + Item_decimal(const char *str, const my_decimal *val_arg, + uint decimal_par, uint length); + Item_decimal(my_decimal *value_par); + Item_decimal(longlong val, In_C_you_should_use_my_bool_instead() unsig); + Item_decimal(double val, int precision, int scale); + Item_decimal(const uchar *bin, int precision, int scale); + enum Type type() const { return DECIMAL_ITEM; } + enum Item_result result_type () const { return DECIMAL_RESULT; } + enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; } + longlong val_int(); + double val_real(); + String *val_str(String*); + my_decimal *val_decimal(my_decimal *val) { return &decimal_value; } + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + In_C_you_should_use_my_bool_instead() basic_const_item() const { return 1; } + Item *clone_item() + { + return new Item_decimal(name, &decimal_value, decimals, max_length); + } + virtual void print(String *str, enum_query_type query_type); + Item_num *neg() + { + my_decimal_neg(&decimal_value); + unsigned_flag= !decimal_value.sign(); + return this; + } + uint decimal_precision() const { return decimal_value.precision(); } + In_C_you_should_use_my_bool_instead() eq(const Item *, In_C_you_should_use_my_bool_instead() binary_cmp) const; + void set_decimal_value(my_decimal *value_par); + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *bool_arg) { return (0);} +}; +class Item_float :public Item_num +{ + char *presentation; +public: + double value; + Item_float(const char *str_arg, uint length); + Item_float(const char *str,double val_arg,uint decimal_par,uint length) + :value(val_arg) + { + presentation= name=(char*) str; + decimals=(uint8) decimal_par; + max_length=length; + fixed= 1; + } + Item_float(double value_par, uint decimal_par) :presentation(0), value(value_par) + { + decimals= (uint8) decimal_par; + fixed= 1; + } + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + enum Type type() const { return REAL_ITEM; } + enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; } + double val_real() { assert(fixed == 1); return value; } + longlong val_int() + { + assert(fixed == 1); + if (value <= (double) ((long long) 0x8000000000000000LL)) + { + return ((long long) 0x8000000000000000LL); + } + else if (value >= (double) (ulonglong) ((long long) 0x7FFFFFFFFFFFFFFFLL)) + { + return ((long long) 0x7FFFFFFFFFFFFFFFLL); + } + return (longlong) rint(value); + } + String *val_str(String*); + my_decimal *val_decimal(my_decimal *); + In_C_you_should_use_my_bool_instead() basic_const_item() const { return 1; } + Item *clone_item() + { return new Item_float(name, value, decimals, max_length); } + Item_num *neg() { value= -value; return this; } + virtual void print(String *str, enum_query_type query_type); + In_C_you_should_use_my_bool_instead() eq(const Item *, In_C_you_should_use_my_bool_instead() binary_cmp) const; +}; +class Item_static_float_func :public Item_float +{ + const char *func_name; +public: + Item_static_float_func(const char *str, double val_arg, uint decimal_par, + uint length) + :Item_float((char *) 0, val_arg, decimal_par, length), func_name(str) + {} + virtual inline void print(String *str, enum_query_type query_type) + { + str->append(func_name); + } + Item *safe_charset_converter(CHARSET_INFO *tocs); +}; +class Item_string :public Item_basic_constant +{ +public: + Item_string(const char *str,uint length, + CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE, + uint repertoire= 3) + : m_cs_specified((0)) + { + str_value.set_or_copy_aligned(str, length, cs); + collation.set(cs, dv, repertoire); + max_length= str_value.numchars()*cs->mbmaxlen; + set_name(str, length, cs); + decimals=31; + fixed= 1; + } + Item_string(CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE) + : m_cs_specified((0)) + { + collation.set(cs, dv); + max_length= 0; + set_name(NULL, 0, cs); + decimals= 31; + fixed= 1; + } + Item_string(const char *name_par, const char *str, uint length, + CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE, + uint repertoire= 3) + : m_cs_specified((0)) + { + str_value.set_or_copy_aligned(str, length, cs); + collation.set(cs, dv, repertoire); + max_length= str_value.numchars()*cs->mbmaxlen; + set_name(name_par, 0, cs); + decimals=31; + fixed= 1; + } + void set_str_with_copy(const char *str_arg, uint length_arg) + { + str_value.copy(str_arg, length_arg, collation.collation); + max_length= str_value.numchars() * collation.collation->mbmaxlen; + } + void set_repertoire_from_value() + { + collation.repertoire= my_string_repertoire(str_value.charset(), + str_value.ptr(), + str_value.length()); + } + enum Type type() const { return STRING_ITEM; } + double val_real(); + longlong val_int(); + String *val_str(String*) + { + assert(fixed == 1); + return (String*) &str_value; + } + my_decimal *val_decimal(my_decimal *); + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + enum Item_result result_type () const { return STRING_RESULT; } + enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; } + In_C_you_should_use_my_bool_instead() basic_const_item() const { return 1; } + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + Item *clone_item() + { + return new Item_string(name, str_value.ptr(), + str_value.length(), collation.collation); + } + Item *safe_charset_converter(CHARSET_INFO *tocs); + inline void append(char *str, uint length) + { + str_value.append(str, length); + max_length= str_value.numchars() * collation.collation->mbmaxlen; + } + virtual void print(String *str, enum_query_type query_type); + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *int_arg) {return (0);} + inline In_C_you_should_use_my_bool_instead() is_cs_specified() const + { + return m_cs_specified; + } + inline void set_cs_specified(In_C_you_should_use_my_bool_instead() cs_specified) + { + m_cs_specified= cs_specified; + } +private: + In_C_you_should_use_my_bool_instead() m_cs_specified; +}; +class Item_static_string_func :public Item_string +{ + const char *func_name; +public: + Item_static_string_func(const char *name_par, const char *str, uint length, + CHARSET_INFO *cs, + Derivation dv= DERIVATION_COERCIBLE) + :Item_string((char *) 0, str, length, cs, dv), func_name(name_par) + {} + Item *safe_charset_converter(CHARSET_INFO *tocs); + virtual inline void print(String *str, enum_query_type query_type) + { + str->append(func_name); + } + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *int_arg) {return (1);} +}; +class Item_partition_func_safe_string: public Item_string +{ +public: + Item_partition_func_safe_string(const char *name, uint length, + CHARSET_INFO *cs= NULL): + Item_string(name, length, cs) + {} +}; +class Item_return_date_time :public Item_partition_func_safe_string +{ + enum_field_types date_time_field_type; +public: + Item_return_date_time(const char *name_arg, enum_field_types field_type_arg) + :Item_partition_func_safe_string(name_arg, 0, &my_charset_bin), + date_time_field_type(field_type_arg) + { } + enum_field_types field_type() const { return date_time_field_type; } +}; +class Item_blob :public Item_partition_func_safe_string +{ +public: + Item_blob(const char *name, uint length) : + Item_partition_func_safe_string(name, length, &my_charset_bin) + { max_length= length; } + enum Type type() const { return TYPE_HOLDER; } + enum_field_types field_type() const { return MYSQL_TYPE_BLOB; } +}; +class Item_empty_string :public Item_partition_func_safe_string +{ +public: + Item_empty_string(const char *header,uint length, CHARSET_INFO *cs= NULL) : + Item_partition_func_safe_string("",0, cs ? cs : &my_charset_utf8_general_ci) + { name=(char*) header; max_length= cs ? length * cs->mbmaxlen : length; } + void make_field(Send_field *field); +}; +class Item_return_int :public Item_int +{ + enum_field_types int_field_type; +public: + Item_return_int(const char *name_arg, uint length, + enum_field_types field_type_arg, longlong value= 0) + :Item_int(name_arg, value, length), int_field_type(field_type_arg) + { + unsigned_flag=1; + } + enum_field_types field_type() const { return int_field_type; } +}; +class Item_hex_string: public Item_basic_constant +{ +public: + Item_hex_string() {} + Item_hex_string(const char *str,uint str_length); + enum Type type() const { return VARBIN_ITEM; } + double val_real() + { + assert(fixed == 1); + return (double) (ulonglong) Item_hex_string::val_int(); + } + longlong val_int(); + In_C_you_should_use_my_bool_instead() basic_const_item() const { return 1; } + String *val_str(String*) { assert(fixed == 1); return &str_value; } + my_decimal *val_decimal(my_decimal *); + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + enum Item_result result_type () const { return STRING_RESULT; } + enum Item_result cast_to_int_type() const { return INT_RESULT; } + enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; } + virtual void print(String *str, enum_query_type query_type); + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + virtual Item *safe_charset_converter(CHARSET_INFO *tocs); + In_C_you_should_use_my_bool_instead() check_partition_func_processor(uchar *int_arg) {return (0);} +}; +class Item_bin_string: public Item_hex_string +{ +public: + Item_bin_string(const char *str,uint str_length); +}; +class Item_result_field :public Item +{ +public: + Field *result_field; + Item_result_field() :result_field(0) {} + Item_result_field(THD *thd, Item_result_field *item): + Item(thd, item), result_field(item->result_field) + {} + ~Item_result_field() {} + Field *get_tmp_table_field() { return result_field; } + Field *tmp_table_field(TABLE *t_arg) { return result_field; } + table_map used_tables() const { return 1; } + virtual void fix_length_and_dec()=0; + void set_result_field(Field *field) { result_field= field; } + In_C_you_should_use_my_bool_instead() is_result_field() { return 1; } + void save_in_result_field(In_C_you_should_use_my_bool_instead() no_conversions) + { + save_in_field(result_field, no_conversions); + } + void cleanup(); +}; +class Item_ref :public Item_ident +{ +protected: + void set_properties(); +public: + enum Ref_Type { REF, DIRECT_REF, VIEW_REF, OUTER_REF }; + Field *result_field; + Item **ref; + Item_ref(Name_resolution_context *context_arg, + const char *db_arg, const char *table_name_arg, + const char *field_name_arg) + :Item_ident(context_arg, db_arg, table_name_arg, field_name_arg), + result_field(0), ref(0) {} + Item_ref(Name_resolution_context *context_arg, Item **item, + const char *table_name_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() alias_name_used_arg= (0)); + Item_ref(THD *thd, Item_ref *item) + :Item_ident(thd, item), result_field(item->result_field), ref(item->ref) {} + enum Type type() const { return REF_ITEM; } + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const + { + Item *it= ((Item *) item)->real_item(); + return ref && (*ref)->eq(it, binary_cmp); + } + double val_real(); + longlong val_int(); + my_decimal *val_decimal(my_decimal *); + In_C_you_should_use_my_bool_instead() val_bool(); + String *val_str(String* tmp); + In_C_you_should_use_my_bool_instead() is_null(); + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + double val_result(); + longlong val_int_result(); + String *str_result(String* tmp); + my_decimal *val_decimal_result(my_decimal *); + In_C_you_should_use_my_bool_instead() val_bool_result(); + In_C_you_should_use_my_bool_instead() send(Protocol *prot, String *tmp); + void make_field(Send_field *field); + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); + void save_org_in_field(Field *field); + enum Item_result result_type () const { return (*ref)->result_type(); } + enum_field_types field_type() const { return (*ref)->field_type(); } + Field *get_tmp_table_field() + { return result_field ? result_field : (*ref)->get_tmp_table_field(); } + Item *get_tmp_table_item(THD *thd); + table_map used_tables() const + { + return depended_from ? (((table_map) 1) << (sizeof(table_map)*8-2)) : (*ref)->used_tables(); + } + void update_used_tables() + { + if (!depended_from) + (*ref)->update_used_tables(); + } + table_map not_null_tables() const { return (*ref)->not_null_tables(); } + void set_result_field(Field *field) { result_field= field; } + In_C_you_should_use_my_bool_instead() is_result_field() { return 1; } + void save_in_result_field(In_C_you_should_use_my_bool_instead() no_conversions) + { + (*ref)->save_in_field(result_field, no_conversions); + } + Item *real_item() + { + return ref ? (*ref)->real_item() : this; + } + In_C_you_should_use_my_bool_instead() walk(Item_processor processor, In_C_you_should_use_my_bool_instead() walk_subquery, uchar *arg) + { return (*ref)->walk(processor, walk_subquery, arg); } + virtual void print(String *str, enum_query_type query_type); + In_C_you_should_use_my_bool_instead() result_as_longlong() + { + return (*ref)->result_as_longlong(); + } + void cleanup(); + Item_field *filed_for_view_update() + { return (*ref)->filed_for_view_update(); } + virtual Ref_Type ref_type() { return REF; } + uint cols() + { + return ref && result_type() == ROW_RESULT ? (*ref)->cols() : 1; + } + Item* element_index(uint i) + { + return ref && result_type() == ROW_RESULT ? (*ref)->element_index(i) : this; + } + Item** addr(uint i) + { + return ref && result_type() == ROW_RESULT ? (*ref)->addr(i) : 0; + } + In_C_you_should_use_my_bool_instead() check_cols(uint c) + { + return ref && result_type() == ROW_RESULT ? (*ref)->check_cols(c) + : Item::check_cols(c); + } + In_C_you_should_use_my_bool_instead() null_inside() + { + return ref && result_type() == ROW_RESULT ? (*ref)->null_inside() : 0; + } + void bring_value() + { + if (ref && result_type() == ROW_RESULT) + (*ref)->bring_value(); + } +}; +class Item_direct_ref :public Item_ref +{ +public: + Item_direct_ref(Name_resolution_context *context_arg, Item **item, + const char *table_name_arg, + const char *field_name_arg, + In_C_you_should_use_my_bool_instead() alias_name_used_arg= (0)) + :Item_ref(context_arg, item, table_name_arg, + field_name_arg, alias_name_used_arg) + {} + Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {} + double val_real(); + longlong val_int(); + String *val_str(String* tmp); + my_decimal *val_decimal(my_decimal *); + In_C_you_should_use_my_bool_instead() val_bool(); + In_C_you_should_use_my_bool_instead() is_null(); + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime,uint fuzzydate); + virtual Ref_Type ref_type() { return DIRECT_REF; } +}; +class Item_direct_view_ref :public Item_direct_ref +{ +public: + Item_direct_view_ref(Name_resolution_context *context_arg, Item **item, + const char *table_name_arg, + const char *field_name_arg) + :Item_direct_ref(context_arg, item, table_name_arg, field_name_arg) {} + Item_direct_view_ref(THD *thd, Item_direct_ref *item) + :Item_direct_ref(thd, item) {} + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + Item *get_tmp_table_item(THD *thd) + { + Item *item= Item_ref::get_tmp_table_item(thd); + item->name= name; + return item; + } + virtual Ref_Type ref_type() { return VIEW_REF; } +}; +class Item_sum; +class Item_outer_ref :public Item_direct_ref +{ +public: + Item *outer_ref; + Item_sum *in_sum_func; + In_C_you_should_use_my_bool_instead() found_in_select_list; + Item_outer_ref(Name_resolution_context *context_arg, + Item_field *outer_field_arg) + :Item_direct_ref(context_arg, 0, outer_field_arg->table_name, + outer_field_arg->field_name), + outer_ref(outer_field_arg), in_sum_func(0), + found_in_select_list(0) + { + ref= &outer_ref; + set_properties(); + fixed= 0; + } + Item_outer_ref(Name_resolution_context *context_arg, Item **item, + const char *table_name_arg, const char *field_name_arg, + In_C_you_should_use_my_bool_instead() alias_name_used_arg) + :Item_direct_ref(context_arg, item, table_name_arg, field_name_arg, + alias_name_used_arg), + outer_ref(0), in_sum_func(0), found_in_select_list(1) + {} + void save_in_result_field(In_C_you_should_use_my_bool_instead() no_conversions) + { + outer_ref->save_org_in_field(result_field); + } + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + table_map used_tables() const + { + return (*ref)->const_item() ? 0 : (((table_map) 1) << (sizeof(table_map)*8-2)); + } + virtual Ref_Type ref_type() { return OUTER_REF; } +}; +class Item_in_subselect; +class Item_ref_null_helper: public Item_ref +{ +protected: + Item_in_subselect* owner; +public: + Item_ref_null_helper(Name_resolution_context *context_arg, + Item_in_subselect* master, Item **item, + const char *table_name_arg, const char *field_name_arg) + :Item_ref(context_arg, item, table_name_arg, field_name_arg), + owner(master) {} + double val_real(); + longlong val_int(); + String* val_str(String* s); + my_decimal *val_decimal(my_decimal *); + In_C_you_should_use_my_bool_instead() val_bool(); + In_C_you_should_use_my_bool_instead() get_date(MYSQL_TIME *ltime, uint fuzzydate); + virtual void print(String *str, enum_query_type query_type); + table_map used_tables() const + { + return (depended_from ? + (((table_map) 1) << (sizeof(table_map)*8-2)) : + (*ref)->used_tables() | (((table_map) 1) << (sizeof(table_map)*8-1))); + } +}; +class Item_int_with_ref :public Item_int +{ + Item *ref; +public: + Item_int_with_ref(longlong i, Item *ref_arg, my_bool unsigned_arg) : + Item_int(i), ref(ref_arg) + { + unsigned_flag= unsigned_arg; + } + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions) + { + return ref->save_in_field(field, no_conversions); + } + Item *clone_item(); + virtual Item *real_item() { return ref; } +}; +class Item_copy_string :public Item +{ + enum enum_field_types cached_field_type; +public: + Item *item; + Item_copy_string(Item *i) :item(i) + { + null_value=maybe_null=item->maybe_null; + decimals=item->decimals; + max_length=item->max_length; + name=item->name; + cached_field_type= item->field_type(); + } + enum Type type() const { return COPY_STR_ITEM; } + enum Item_result result_type () const { return STRING_RESULT; } + enum_field_types field_type() const { return cached_field_type; } + double val_real() + { + int err_not_used; + char *end_not_used; + return (null_value ? 0.0 : + ((str_value.charset())->cset->strntod((str_value.charset()),((char*) str_value.ptr()),(str_value.length()),(&end_not_used),(&err_not_used)))); + } + longlong val_int() + { + int err; + return null_value ? 0LL : ((str_value.charset())->cset->strntoll((str_value.charset()),(str_value.ptr()),(str_value.length()),(10),((char**) 0),(&err))); + } + String *val_str(String*); + my_decimal *val_decimal(my_decimal *); + void make_field(Send_field *field) { item->make_field(field); } + void copy(); + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions) + { + return save_str_value_in_field(field, &str_value); + } + table_map used_tables() const { return (table_map) 1L; } + In_C_you_should_use_my_bool_instead() const_item() const { return 0; } + In_C_you_should_use_my_bool_instead() is_null() { return null_value; } +}; +class Cached_item :public Sql_alloc +{ +public: + my_bool null_value; + Cached_item() :null_value(0) {} + virtual In_C_you_should_use_my_bool_instead() cmp(void)=0; + virtual ~Cached_item(); +}; +class Cached_item_str :public Cached_item +{ + Item *item; + String value,tmp_value; +public: + Cached_item_str(THD *thd, Item *arg); + In_C_you_should_use_my_bool_instead() cmp(void); + ~Cached_item_str(); +}; +class Cached_item_real :public Cached_item +{ + Item *item; + double value; +public: + Cached_item_real(Item *item_par) :item(item_par),value(0.0) {} + In_C_you_should_use_my_bool_instead() cmp(void); +}; +class Cached_item_int :public Cached_item +{ + Item *item; + longlong value; +public: + Cached_item_int(Item *item_par) :item(item_par),value(0) {} + In_C_you_should_use_my_bool_instead() cmp(void); +}; +class Cached_item_decimal :public Cached_item +{ + Item *item; + my_decimal value; +public: + Cached_item_decimal(Item *item_par); + In_C_you_should_use_my_bool_instead() cmp(void); +}; +class Cached_item_field :public Cached_item +{ + uchar *buff; + Field *field; + uint length; +public: + Cached_item_field(Item_field *item) + { + field= item->field; + buff= (uchar*) sql_calloc(length=field->pack_length()); + } + In_C_you_should_use_my_bool_instead() cmp(void); +}; +class Item_default_value : public Item_field +{ +public: + Item *arg; + Item_default_value(Name_resolution_context *context_arg) + :Item_field(context_arg, (const char *)NULL, (const char *)NULL, + (const char *)NULL), + arg(NULL) {} + Item_default_value(Name_resolution_context *context_arg, Item *a) + :Item_field(context_arg, (const char *)NULL, (const char *)NULL, + (const char *)NULL), + arg(a) {} + enum Type type() const { return DEFAULT_VALUE_ITEM; } + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + virtual void print(String *str, enum_query_type query_type); + int save_in_field(Field *field_arg, In_C_you_should_use_my_bool_instead() no_conversions); + table_map used_tables() const { return (table_map)0L; } + In_C_you_should_use_my_bool_instead() walk(Item_processor processor, In_C_you_should_use_my_bool_instead() walk_subquery, uchar *args) + { + return arg->walk(processor, walk_subquery, args) || + (this->*processor)(args); + } + Item *transform(Item_transformer transformer, uchar *args); +}; +class Item_insert_value : public Item_field +{ +public: + Item *arg; + Item_insert_value(Name_resolution_context *context_arg, Item *a) + :Item_field(context_arg, (const char *)NULL, (const char *)NULL, + (const char *)NULL), + arg(a) {} + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + virtual void print(String *str, enum_query_type query_type); + int save_in_field(Field *field_arg, In_C_you_should_use_my_bool_instead() no_conversions) + { + return Item_field::save_in_field(field_arg, no_conversions); + } + table_map used_tables() const { return (((table_map) 1) << (sizeof(table_map)*8-1)); } + In_C_you_should_use_my_bool_instead() walk(Item_processor processor, In_C_you_should_use_my_bool_instead() walk_subquery, uchar *args) + { + return arg->walk(processor, walk_subquery, args) || + (this->*processor)(args); + } +}; +enum trg_action_time_type +{ + TRG_ACTION_BEFORE= 0, TRG_ACTION_AFTER= 1, TRG_ACTION_MAX +}; +class Table_triggers_list; +class Item_trigger_field : public Item_field, + private Settable_routine_parameter +{ +public: + enum row_version_type {OLD_ROW, NEW_ROW}; + row_version_type row_version; + Item_trigger_field *next_trg_field; + uint field_idx; + Table_triggers_list *triggers; + Item_trigger_field(Name_resolution_context *context_arg, + row_version_type row_ver_arg, + const char *field_name_arg, + ulong priv, const In_C_you_should_use_my_bool_instead() ro) + :Item_field(context_arg, + (const char *)NULL, (const char *)NULL, field_name_arg), + row_version(row_ver_arg), field_idx((uint)-1), original_privilege(priv), + want_privilege(priv), table_grants(NULL), read_only (ro) + {} + void setup_field(THD *thd, TABLE *table, GRANT_INFO *table_grant_info); + enum Type type() const { return TRIGGER_FIELD_ITEM; } + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const; + In_C_you_should_use_my_bool_instead() fix_fields(THD *, Item **); + virtual void print(String *str, enum_query_type query_type); + table_map used_tables() const { return (table_map)0L; } + Field *get_tmp_table_field() { return 0; } + Item *copy_or_same(THD *thd) { return this; } + Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); } + void cleanup(); +private: + void set_required_privilege(In_C_you_should_use_my_bool_instead() rw); + In_C_you_should_use_my_bool_instead() set_value(THD *thd, sp_rcontext *ctx, Item **it); +public: + Settable_routine_parameter *get_settable_routine_parameter() + { + return (read_only ? 0 : this); + } + In_C_you_should_use_my_bool_instead() set_value(THD *thd, Item **it) + { + return set_value(thd, NULL, it); + } +private: + ulong original_privilege; + ulong want_privilege; + GRANT_INFO *table_grants; + In_C_you_should_use_my_bool_instead() read_only; +}; +class Item_cache: public Item_basic_constant +{ +protected: + Item *example; + table_map used_table_map; + Field *cached_field; + enum enum_field_types cached_field_type; +public: + Item_cache(): + example(0), used_table_map(0), cached_field(0), cached_field_type(MYSQL_TYPE_STRING) + { + fixed= 1; + null_value= 1; + } + Item_cache(enum_field_types field_type_arg): + example(0), used_table_map(0), cached_field(0), cached_field_type(field_type_arg) + { + fixed= 1; + null_value= 1; + } + void set_used_tables(table_map map) { used_table_map= map; } + virtual In_C_you_should_use_my_bool_instead() allocate(uint i) { return 0; } + virtual In_C_you_should_use_my_bool_instead() setup(Item *item) + { + example= item; + max_length= item->max_length; + decimals= item->decimals; + collation.set(item->collation); + unsigned_flag= item->unsigned_flag; + if (item->type() == FIELD_ITEM) + cached_field= ((Item_field *)item)->field; + return 0; + }; + virtual void store(Item *)= 0; + enum Type type() const { return CACHE_ITEM; } + enum_field_types field_type() const { return cached_field_type; } + static Item_cache* get_cache(const Item *item); + table_map used_tables() const { return used_table_map; } + virtual void keep_array() {} + virtual void print(String *str, enum_query_type query_type); + In_C_you_should_use_my_bool_instead() eq_def(Field *field) + { + return cached_field ? cached_field->eq_def (field) : (0); + } + In_C_you_should_use_my_bool_instead() eq(const Item *item, In_C_you_should_use_my_bool_instead() binary_cmp) const + { + return this == item; + } +}; +class Item_cache_int: public Item_cache +{ +protected: + longlong value; +public: + Item_cache_int(): Item_cache(), value(0) {} + Item_cache_int(enum_field_types field_type_arg): + Item_cache(field_type_arg), value(0) {} + void store(Item *item); + void store(Item *item, longlong val_arg); + double val_real() { assert(fixed == 1); return (double) value; } + longlong val_int() { assert(fixed == 1); return value; } + String* val_str(String *str); + my_decimal *val_decimal(my_decimal *); + enum Item_result result_type() const { return INT_RESULT; } + In_C_you_should_use_my_bool_instead() result_as_longlong() { return (1); } +}; +class Item_cache_real: public Item_cache +{ + double value; +public: + Item_cache_real(): Item_cache(), value(0) {} + void store(Item *item); + double val_real() { assert(fixed == 1); return value; } + longlong val_int(); + String* val_str(String *str); + my_decimal *val_decimal(my_decimal *); + enum Item_result result_type() const { return REAL_RESULT; } +}; +class Item_cache_decimal: public Item_cache +{ +protected: + my_decimal decimal_value; +public: + Item_cache_decimal(): Item_cache() {} + void store(Item *item); + double val_real(); + longlong val_int(); + String* val_str(String *str); + my_decimal *val_decimal(my_decimal *); + enum Item_result result_type() const { return DECIMAL_RESULT; } +}; +class Item_cache_str: public Item_cache +{ + char buffer[80]; + String *value, value_buff; + In_C_you_should_use_my_bool_instead() is_varbinary; +public: + Item_cache_str(const Item *item) : + Item_cache(), value(0), + is_varbinary(item->type() == FIELD_ITEM && + ((const Item_field *) item)->field->type() == + MYSQL_TYPE_VARCHAR && + !((const Item_field *) item)->field->has_charset()) + {} + void store(Item *item); + double val_real(); + longlong val_int(); + String* val_str(String *) { assert(fixed == 1); return value; } + my_decimal *val_decimal(my_decimal *); + enum Item_result result_type() const { return STRING_RESULT; } + CHARSET_INFO *charset() const { return value->charset(); }; + int save_in_field(Field *field, In_C_you_should_use_my_bool_instead() no_conversions); +}; +class Item_cache_row: public Item_cache +{ + Item_cache **values; + uint item_count; + In_C_you_should_use_my_bool_instead() save_array; +public: + Item_cache_row() + :Item_cache(), values(0), item_count(2), save_array(0) {} + In_C_you_should_use_my_bool_instead() allocate(uint num); + In_C_you_should_use_my_bool_instead() setup(Item *item); + void store(Item *item); + void illegal_method_call(const char *); + void make_field(Send_field *) + { + illegal_method_call((const char*)"make_field"); + }; + double val_real() + { + illegal_method_call((const char*)"val"); + return 0; + }; + longlong val_int() + { + illegal_method_call((const char*)"val_int"); + return 0; + }; + String *val_str(String *) + { + illegal_method_call((const char*)"val_str"); + return 0; + }; + my_decimal *val_decimal(my_decimal *val) + { + illegal_method_call((const char*)"val_decimal"); + return 0; + }; + enum Item_result result_type() const { return ROW_RESULT; } + uint cols() { return item_count; } + Item *element_index(uint i) { return values[i]; } + Item **addr(uint i) { return (Item **) (values + i); } + In_C_you_should_use_my_bool_instead() check_cols(uint c); + In_C_you_should_use_my_bool_instead() null_inside(); + void bring_value(); + void keep_array() { save_array= 1; } + void cleanup() + { + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("Item_cache_row::cleanup","./sql/item.h",2898,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + Item_cache::cleanup(); + if (save_array) + bzero(values, item_count*sizeof(Item**)); + else + values= 0; + do {_db_return_ (2904, &_db_func_, &_db_file_, &_db_level_); return;} while(0); + } +}; +class Item_type_holder: public Item +{ +protected: + TYPELIB *enum_set_typelib; + enum_field_types fld_type; + Field::geometry_type geometry_type; + void get_full_info(Item *item); + int prev_decimal_int_part; +public: + Item_type_holder(THD*, Item*); + Item_result result_type() const; + enum_field_types field_type() const { return fld_type; }; + enum Type type() const { return TYPE_HOLDER; } + double val_real(); + longlong val_int(); + my_decimal *val_decimal(my_decimal *); + String *val_str(String*); + In_C_you_should_use_my_bool_instead() join_types(THD *thd, Item *); + Field *make_field_by_type(TABLE *table); + static uint32 display_length(Item *item); + static enum_field_types get_real_type(Item *); + Field::geometry_type get_geometry_type() const { return geometry_type; }; +}; +class st_select_lex; +void mark_select_range_as_dependent(THD *thd, + st_select_lex *last_select, + st_select_lex *current_sel, + Field *found_field, Item *found_item, + Item_ident *resolved_item); +extern Cached_item *new_Cached_item(THD *thd, Item *item); +extern Item_result item_cmp_type(Item_result a,Item_result b); +extern void resolve_const_item(THD *thd, Item **ref, Item *cmp_item); +extern In_C_you_should_use_my_bool_instead() field_is_equal_to_item(Field *field,Item *item); +extern my_decimal decimal_zero; +void free_items(Item *item); +void cleanup_items(Item *item); +class THD; +void close_thread_tables(THD *thd); +In_C_you_should_use_my_bool_instead() check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *tables); +In_C_you_should_use_my_bool_instead() check_single_table_access(THD *thd, ulong privilege, + TABLE_LIST *tables, In_C_you_should_use_my_bool_instead() no_errors); +In_C_you_should_use_my_bool_instead() check_routine_access(THD *thd,ulong want_access,char *db,char *name, + In_C_you_should_use_my_bool_instead() is_proc, In_C_you_should_use_my_bool_instead() no_errors); +In_C_you_should_use_my_bool_instead() check_some_access(THD *thd, ulong want_access, TABLE_LIST *table); +In_C_you_should_use_my_bool_instead() check_some_routine_access(THD *thd, const char *db, const char *name, In_C_you_should_use_my_bool_instead() is_proc); +In_C_you_should_use_my_bool_instead() multi_update_precheck(THD *thd, TABLE_LIST *tables); +In_C_you_should_use_my_bool_instead() multi_delete_precheck(THD *thd, TABLE_LIST *tables); +int mysql_multi_update_prepare(THD *thd); +int mysql_multi_delete_prepare(THD *thd); +In_C_you_should_use_my_bool_instead() mysql_insert_select_prepare(THD *thd); +In_C_you_should_use_my_bool_instead() update_precheck(THD *thd, TABLE_LIST *tables); +In_C_you_should_use_my_bool_instead() delete_precheck(THD *thd, TABLE_LIST *tables); +In_C_you_should_use_my_bool_instead() insert_precheck(THD *thd, TABLE_LIST *tables); +In_C_you_should_use_my_bool_instead() create_table_precheck(THD *thd, TABLE_LIST *tables, + TABLE_LIST *create_table); +int append_query_string(CHARSET_INFO *csinfo, + String const *from, String *to); +void get_default_definer(THD *thd, LEX_USER *definer); +LEX_USER *create_default_definer(THD *thd); +LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name); +LEX_USER *get_current_user(THD *thd, LEX_USER *user); +In_C_you_should_use_my_bool_instead() check_string_byte_length(LEX_STRING *str, const char *err_msg, + uint max_byte_length); +In_C_you_should_use_my_bool_instead() check_string_char_length(LEX_STRING *str, const char *err_msg, + uint max_char_length, CHARSET_INFO *cs, + In_C_you_should_use_my_bool_instead() no_error); +In_C_you_should_use_my_bool_instead() test_if_data_home_dir(const char *dir); +In_C_you_should_use_my_bool_instead() parse_sql(THD *thd, + class Lex_input_stream *lip, + class Object_creation_ctx *creation_ctx); +enum enum_mysql_completiontype { + ROLLBACK_RELEASE=-2, ROLLBACK=1, ROLLBACK_AND_CHAIN=7, + COMMIT_RELEASE=-1, COMMIT=0, COMMIT_AND_CHAIN=6 +}; +In_C_you_should_use_my_bool_instead() begin_trans(THD *thd); +In_C_you_should_use_my_bool_instead() end_active_trans(THD *thd); +int end_trans(THD *thd, enum enum_mysql_completiontype completion); +Item *negate_expression(THD *thd, Item *expr); +int vprint_msg_to_log(enum loglevel level, const char *format, va_list args); +void sql_print_error(const char *format, ...) __attribute__((format(printf, 1, 2))); +void sql_print_warning(const char *format, ...) __attribute__((format(printf, 1, 2))); +void sql_print_information(const char *format, ...) + __attribute__((format(printf, 1, 2))); +typedef void (*sql_print_message_func)(const char *format, ...) + __attribute__((format(printf, 1, 2))); +extern sql_print_message_func sql_print_message_handlers[]; +int error_log_print(enum loglevel level, const char *format, + va_list args); +In_C_you_should_use_my_bool_instead() slow_log_print(THD *thd, const char *query, uint query_length, + ulonglong current_utime); +In_C_you_should_use_my_bool_instead() general_log_print(THD *thd, enum enum_server_command command, + const char *format,...); +In_C_you_should_use_my_bool_instead() general_log_write(THD *thd, enum enum_server_command command, + const char *query, uint query_length); +#include "sql_class.h" +#include "log.h" +class Relay_log_info; +class Format_description_log_event; +class TC_LOG +{ + public: + int using_heuristic_recover(); + TC_LOG() {} + virtual ~TC_LOG() {} + virtual int open(const char *opt_name)=0; + virtual void close()=0; + virtual int log_xid(THD *thd, my_xid xid)=0; + virtual void unlog(ulong cookie, my_xid xid)=0; +}; +class TC_LOG_DUMMY: public TC_LOG +{ +public: + TC_LOG_DUMMY() {} + int open(const char *opt_name) { return 0; } + void close() { } + int log_xid(THD *thd, my_xid xid) { return 1; } + void unlog(ulong cookie, my_xid xid) { } +}; +class TC_LOG_MMAP: public TC_LOG +{ + public: + typedef enum { + POOL, + ERROR, + DIRTY + } PAGE_STATE; + private: + typedef struct st_page { + struct st_page *next; + my_xid *start, *end; + my_xid *ptr; + int size, free; + int waiters; + PAGE_STATE state; + pthread_mutex_t lock; + pthread_cond_t cond; + } PAGE; + char logname[512]; + File fd; + my_off_t file_length; + uint npages, inited; + uchar *data; + struct st_page *pages, *syncing, *active, *pool, *pool_last; + pthread_mutex_t LOCK_active, LOCK_pool, LOCK_sync; + pthread_cond_t COND_pool, COND_active; + public: + TC_LOG_MMAP(): inited(0) {} + int open(const char *opt_name); + void close(); + int log_xid(THD *thd, my_xid xid); + void unlog(ulong cookie, my_xid xid); + int recover(); + private: + void get_active_from_pool(); + int sync(); + int overflow(); +}; +extern TC_LOG *tc_log; +extern TC_LOG_MMAP tc_log_mmap; +extern TC_LOG_DUMMY tc_log_dummy; +class Relay_log_info; +typedef struct st_log_info +{ + char log_file_name[512]; + my_off_t index_file_offset, index_file_start_offset; + my_off_t pos; + In_C_you_should_use_my_bool_instead() fatal; + pthread_mutex_t lock; + st_log_info() + : index_file_offset(0), index_file_start_offset(0), + pos(0), fatal(0) + { + log_file_name[0] = '\0'; + pthread_mutex_init(&lock, NULL); + } + ~st_log_info() { pthread_mutex_destroy(&lock);} +} LOG_INFO; +class Log_event; +class Rows_log_event; +enum enum_log_type { LOG_UNKNOWN, LOG_NORMAL, LOG_BIN }; +enum enum_log_state { LOG_OPENED, LOG_CLOSED, LOG_TO_BE_OPENED }; +class MYSQL_LOG +{ +public: + MYSQL_LOG(); + void init_pthread_objects(); + void cleanup(); + In_C_you_should_use_my_bool_instead() open(const char *log_name, + enum_log_type log_type, + const char *new_name, + enum cache_type io_cache_type_arg); + void init(enum_log_type log_type_arg, + enum cache_type io_cache_type_arg); + void close(uint exiting); + inline In_C_you_should_use_my_bool_instead() is_open() { return log_state != LOG_CLOSED; } + const char *generate_name(const char *log_name, const char *suffix, + In_C_you_should_use_my_bool_instead() strip_ext, char *buff); + int generate_new_name(char *new_name, const char *log_name); + protected: + pthread_mutex_t LOCK_log; + char *name; + char log_file_name[512]; + char time_buff[20], db[(64*3) + 1]; + In_C_you_should_use_my_bool_instead() write_error, inited; + IO_CACHE log_file; + enum_log_type log_type; + volatile enum_log_state log_state; + enum cache_type io_cache_type; + friend class Log_event; +}; +class MYSQL_QUERY_LOG: public MYSQL_LOG +{ +public: + MYSQL_QUERY_LOG() : last_time(0) {} + void reopen_file(); + In_C_you_should_use_my_bool_instead() write(time_t event_time, const char *user_host, + uint user_host_len, int thread_id, + const char *command_type, uint command_type_len, + const char *sql_text, uint sql_text_len); + In_C_you_should_use_my_bool_instead() write(THD *thd, time_t current_time, time_t query_start_arg, + const char *user_host, uint user_host_len, + ulonglong query_utime, ulonglong lock_utime, In_C_you_should_use_my_bool_instead() is_command, + const char *sql_text, uint sql_text_len); + In_C_you_should_use_my_bool_instead() open_slow_log(const char *log_name) + { + char buf[512]; + return open(generate_name(log_name, "-slow.log", 0, buf), LOG_NORMAL, 0, + WRITE_CACHE); + } + In_C_you_should_use_my_bool_instead() open_query_log(const char *log_name) + { + char buf[512]; + return open(generate_name(log_name, ".log", 0, buf), LOG_NORMAL, 0, + WRITE_CACHE); + } +private: + time_t last_time; +}; +class MYSQL_BIN_LOG: public TC_LOG, private MYSQL_LOG +{ + private: + pthread_mutex_t LOCK_index; + pthread_mutex_t LOCK_prep_xids; + pthread_cond_t COND_prep_xids; + pthread_cond_t update_cond; + ulonglong bytes_written; + IO_CACHE index_file; + char index_file_name[512]; + ulong max_size; + long prepared_xids; + uint file_id; + uint open_count; + int readers_count; + In_C_you_should_use_my_bool_instead() need_start_event; + In_C_you_should_use_my_bool_instead() no_auto_events; + ulonglong m_table_map_version; + int write_to_file(IO_CACHE *cache); + void new_file_without_locking(); + void new_file_impl(In_C_you_should_use_my_bool_instead() need_lock); +public: + MYSQL_LOG::generate_name; + MYSQL_LOG::is_open; + Format_description_log_event *description_event_for_exec, + *description_event_for_queue; + MYSQL_BIN_LOG(); + int open(const char *opt_name); + void close(); + int log_xid(THD *thd, my_xid xid); + void unlog(ulong cookie, my_xid xid); + int recover(IO_CACHE *log, Format_description_log_event *fdle); + In_C_you_should_use_my_bool_instead() is_table_mapped(TABLE *table) const + { + return table->s->table_map_version == table_map_version(); + } + ulonglong table_map_version() const { return m_table_map_version; } + void update_table_map_version() { ++m_table_map_version; } + int flush_and_set_pending_rows_event(THD *thd, Rows_log_event* event); + void reset_bytes_written() + { + bytes_written = 0; + } + void harvest_bytes_written(ulonglong* counter) + { + char buf1[22],buf2[22]; + const char *_db_func_, *_db_file_; uint _db_level_; char **_db_framep_; _db_enter_ ("harvest_bytes_written","./sql/log.h",321,&_db_func_,&_db_file_,&_db_level_, &_db_framep_); + (*counter)+=bytes_written; + do {_db_pargs_(324,"info"); _db_doprnt_ ("counter: %s bytes_written: %s", llstr(*counter,buf1), llstr(bytes_written,buf2));} while(0); + bytes_written=0; + do {_db_return_ (326, &_db_func_, &_db_file_, &_db_level_); return;} while(0); + } + void set_max_size(ulong max_size_arg); + void signal_update(); + void wait_for_update(THD* thd, In_C_you_should_use_my_bool_instead() master_or_slave); + void set_need_start_event() { need_start_event = 1; } + void init(In_C_you_should_use_my_bool_instead() no_auto_events_arg, ulong max_size); + void init_pthread_objects(); + void cleanup(); + In_C_you_should_use_my_bool_instead() open(const char *log_name, + enum_log_type log_type, + const char *new_name, + enum cache_type io_cache_type_arg, + In_C_you_should_use_my_bool_instead() no_auto_events_arg, ulong max_size, + In_C_you_should_use_my_bool_instead() null_created); + In_C_you_should_use_my_bool_instead() open_index_file(const char *index_file_name_arg, + const char *log_name); + void new_file(); + In_C_you_should_use_my_bool_instead() write(Log_event* event_info); + In_C_you_should_use_my_bool_instead() write(THD *thd, IO_CACHE *cache, Log_event *commit_event); + int write_cache(IO_CACHE *cache, In_C_you_should_use_my_bool_instead() lock_log, In_C_you_should_use_my_bool_instead() flush_and_sync); + void start_union_events(THD *thd, query_id_t query_id_param); + void stop_union_events(THD *thd); + In_C_you_should_use_my_bool_instead() is_query_in_union(THD *thd, query_id_t query_id_param); + In_C_you_should_use_my_bool_instead() appendv(const char* buf,uint len,...); + In_C_you_should_use_my_bool_instead() append(Log_event* ev); + void make_log_name(char* buf, const char* log_ident); + In_C_you_should_use_my_bool_instead() is_active(const char* log_file_name); + int update_log_index(LOG_INFO* linfo, In_C_you_should_use_my_bool_instead() need_update_threads); + void rotate_and_purge(uint flags); + In_C_you_should_use_my_bool_instead() flush_and_sync(); + int purge_logs(const char *to_log, In_C_you_should_use_my_bool_instead() included, + In_C_you_should_use_my_bool_instead() need_mutex, In_C_you_should_use_my_bool_instead() need_update_threads, + ulonglong *decrease_log_space); + int purge_logs_before_date(time_t purge_time); + int purge_first_log(Relay_log_info* rli, In_C_you_should_use_my_bool_instead() included); + In_C_you_should_use_my_bool_instead() reset_logs(THD* thd); + void close(uint exiting); + int find_log_pos(LOG_INFO* linfo, const char* log_name, + In_C_you_should_use_my_bool_instead() need_mutex); + int find_next_log(LOG_INFO* linfo, In_C_you_should_use_my_bool_instead() need_mutex); + int get_current_log(LOG_INFO* linfo); + int raw_get_current_log(LOG_INFO* linfo); + uint next_file_id(); + inline char* get_index_fname() { return index_file_name;} + inline char* get_log_fname() { return log_file_name; } + inline char* get_name() { return name; } + inline pthread_mutex_t* get_log_lock() { return &LOCK_log; } + inline IO_CACHE* get_log_file() { return &log_file; } + inline void lock_index() { pthread_mutex_lock(&LOCK_index);} + inline void unlock_index() { pthread_mutex_unlock(&LOCK_index);} + inline IO_CACHE *get_index_file() { return &index_file;} + inline uint32 get_open_count() { return open_count; } +}; +class Log_event_handler +{ +public: + Log_event_handler() {} + virtual In_C_you_should_use_my_bool_instead() init()= 0; + virtual void cleanup()= 0; + virtual In_C_you_should_use_my_bool_instead() log_slow(THD *thd, time_t current_time, + time_t query_start_arg, const char *user_host, + uint user_host_len, ulonglong query_utime, + ulonglong lock_utime, In_C_you_should_use_my_bool_instead() is_command, + const char *sql_text, uint sql_text_len)= 0; + virtual In_C_you_should_use_my_bool_instead() log_error(enum loglevel level, const char *format, + va_list args)= 0; + virtual In_C_you_should_use_my_bool_instead() log_general(THD *thd, time_t event_time, const char *user_host, + uint user_host_len, int thread_id, + const char *command_type, uint command_type_len, + const char *sql_text, uint sql_text_len, + CHARSET_INFO *client_cs)= 0; + virtual ~Log_event_handler() {} +}; +int check_if_log_table(uint db_len, const char *db, uint table_name_len, + const char *table_name, uint check_if_opened); +class Log_to_csv_event_handler: public Log_event_handler +{ + friend class LOGGER; +public: + Log_to_csv_event_handler(); + ~Log_to_csv_event_handler(); + virtual In_C_you_should_use_my_bool_instead() init(); + virtual void cleanup(); + virtual In_C_you_should_use_my_bool_instead() log_slow(THD *thd, time_t current_time, + time_t query_start_arg, const char *user_host, + uint user_host_len, ulonglong query_utime, + ulonglong lock_utime, In_C_you_should_use_my_bool_instead() is_command, + const char *sql_text, uint sql_text_len); + virtual In_C_you_should_use_my_bool_instead() log_error(enum loglevel level, const char *format, + va_list args); + virtual In_C_you_should_use_my_bool_instead() log_general(THD *thd, time_t event_time, const char *user_host, + uint user_host_len, int thread_id, + const char *command_type, uint command_type_len, + const char *sql_text, uint sql_text_len, + CHARSET_INFO *client_cs); + int activate_log(THD *thd, uint log_type); +}; +class Log_to_file_event_handler: public Log_event_handler +{ + MYSQL_QUERY_LOG mysql_log; + MYSQL_QUERY_LOG mysql_slow_log; + In_C_you_should_use_my_bool_instead() is_initialized; +public: + Log_to_file_event_handler(): is_initialized((0)) + {} + virtual In_C_you_should_use_my_bool_instead() init(); + virtual void cleanup(); + virtual In_C_you_should_use_my_bool_instead() log_slow(THD *thd, time_t current_time, + time_t query_start_arg, const char *user_host, + uint user_host_len, ulonglong query_utime, + ulonglong lock_utime, In_C_you_should_use_my_bool_instead() is_command, + const char *sql_text, uint sql_text_len); + virtual In_C_you_should_use_my_bool_instead() log_error(enum loglevel level, const char *format, + va_list args); + virtual In_C_you_should_use_my_bool_instead() log_general(THD *thd, time_t event_time, const char *user_host, + uint user_host_len, int thread_id, + const char *command_type, uint command_type_len, + const char *sql_text, uint sql_text_len, + CHARSET_INFO *client_cs); + void flush(); + void init_pthread_objects(); + MYSQL_QUERY_LOG *get_mysql_slow_log() { return &mysql_slow_log; } + MYSQL_QUERY_LOG *get_mysql_log() { return &mysql_log; } +}; +class LOGGER +{ + pthread_rwlock_t LOCK_logger; + uint inited; + Log_to_csv_event_handler *table_log_handler; + Log_to_file_event_handler *file_log_handler; + Log_event_handler *error_log_handler_list[3 + 1]; + Log_event_handler *slow_log_handler_list[3 + 1]; + Log_event_handler *general_log_handler_list[3 + 1]; +public: + In_C_you_should_use_my_bool_instead() is_log_tables_initialized; + LOGGER() : inited(0), table_log_handler(NULL), + file_log_handler(NULL), is_log_tables_initialized((0)) + {} + void lock_shared() { pthread_rwlock_rdlock(&LOCK_logger); } + void lock_exclusive() { pthread_rwlock_wrlock(&LOCK_logger); } + void unlock() { pthread_rwlock_unlock(&LOCK_logger); } + In_C_you_should_use_my_bool_instead() is_log_table_enabled(uint log_table_type); + In_C_you_should_use_my_bool_instead() log_command(THD *thd, enum enum_server_command command); + void init_base(); + void init_log_tables(); + In_C_you_should_use_my_bool_instead() flush_logs(THD *thd); + void cleanup_base(); + void cleanup_end(); + In_C_you_should_use_my_bool_instead() error_log_print(enum loglevel level, const char *format, + va_list args); + In_C_you_should_use_my_bool_instead() slow_log_print(THD *thd, const char *query, uint query_length, + ulonglong current_utime); + In_C_you_should_use_my_bool_instead() general_log_print(THD *thd,enum enum_server_command command, + const char *format, va_list args); + In_C_you_should_use_my_bool_instead() general_log_write(THD *thd, enum enum_server_command command, + const char *query, uint query_length); + int set_handlers(uint error_log_printer, + uint slow_log_printer, + uint general_log_printer); + void init_error_log(uint error_log_printer); + void init_slow_log(uint slow_log_printer); + void init_general_log(uint general_log_printer); + void deactivate_log_handler(THD* thd, uint log_type); + In_C_you_should_use_my_bool_instead() activate_log_handler(THD* thd, uint log_type); + MYSQL_QUERY_LOG *get_slow_log_file_handler() + { + if (file_log_handler) + return file_log_handler->get_mysql_slow_log(); + return NULL; + } + MYSQL_QUERY_LOG *get_log_file_handler() + { + if (file_log_handler) + return file_log_handler->get_mysql_log(); + return NULL; + } +}; +enum enum_binlog_format { + BINLOG_FORMAT_MIXED= 0, + BINLOG_FORMAT_STMT= 1, + BINLOG_FORMAT_ROW= 2, + BINLOG_FORMAT_UNSPEC= 3 +}; +extern TYPELIB binlog_format_typelib; +#include "rpl_tblmap.h" +struct st_table; +typedef st_table TABLE; +class table_mapping { +private: + MEM_ROOT m_mem_root; +public: + enum enum_error { + ERR_NO_ERROR = 0, + ERR_LIMIT_EXCEEDED, + ERR_MEMORY_ALLOCATION + }; + table_mapping(); + ~table_mapping(); + TABLE* get_table(ulong table_id); + int set_table(ulong table_id, TABLE* table); + int remove_table(ulong table_id); + void clear_tables(); + ulong count() const { return m_table_ids.records; } +private: + struct entry { + ulong table_id; + union { + TABLE *table; + entry *next; + }; + }; + entry *find_entry(ulong table_id) + { + return (entry *)hash_search(&m_table_ids, + (uchar*)&table_id, + sizeof(table_id)); + } + int expand(); + entry *m_free; + HASH m_table_ids; +}; +class Reprepare_observer +{ +public: + In_C_you_should_use_my_bool_instead() report_error(THD *thd); + In_C_you_should_use_my_bool_instead() is_invalidated() const { return m_invalidated; } + void reset_reprepare_observer() { m_invalidated= (0); } +private: + In_C_you_should_use_my_bool_instead() m_invalidated; +}; +class Relay_log_info; +class Query_log_event; +class Load_log_event; +class Slave_log_event; +class sp_rcontext; +class sp_cache; +class Lex_input_stream; +class Rows_log_event; +enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE }; +enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME }; +enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE }; +enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON, + DELAY_KEY_WRITE_ALL }; +enum enum_slave_exec_mode { SLAVE_EXEC_MODE_STRICT, + SLAVE_EXEC_MODE_IDEMPOTENT, + SLAVE_EXEC_MODE_LAST_BIT}; +enum enum_mark_columns +{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE}; +extern char internal_table_name[2]; +extern char empty_c_string[1]; +extern const char **errmesg; +extern uint tc_heuristic_recover; +typedef struct st_user_var_events +{ + user_var_entry *user_var_event; + char *value; + ulong length; + Item_result type; + uint charset_number; +} BINLOG_USER_VAR_EVENT; +typedef struct st_copy_info { + ha_rows records; + ha_rows deleted; + ha_rows updated; + ha_rows copied; + ha_rows error_count; + ha_rows touched; + enum enum_duplicates handle_duplicates; + int escape_char, last_errno; + In_C_you_should_use_my_bool_instead() ignore; + List<Item> *update_fields; + List<Item> *update_values; + TABLE_LIST *view; +} COPY_INFO; +class Key_part_spec :public Sql_alloc { +public: + const char *field_name; + uint length; + Key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {} + In_C_you_should_use_my_bool_instead() operator==(const Key_part_spec& other) const; + Key_part_spec *clone(MEM_ROOT *mem_root) const + { return new (mem_root) Key_part_spec(*this); } +}; +class Alter_drop :public Sql_alloc { +public: + enum drop_type {KEY, COLUMN }; + const char *name; + enum drop_type type; + Alter_drop(enum drop_type par_type,const char *par_name) + :name(par_name), type(par_type) {} + Alter_drop *clone(MEM_ROOT *mem_root) const + { return new (mem_root) Alter_drop(*this); } +}; +class Alter_column :public Sql_alloc { +public: + const char *name; + Item *def; + Alter_column(const char *par_name,Item *literal) + :name(par_name), def(literal) {} + Alter_column *clone(MEM_ROOT *mem_root) const + { return new (mem_root) Alter_column(*this); } +}; +class Key :public Sql_alloc { +public: + enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY}; + enum Keytype type; + KEY_CREATE_INFO key_create_info; + List<Key_part_spec> columns; + const char *name; + In_C_you_should_use_my_bool_instead() generated; + Key(enum Keytype type_par, const char *name_arg, + KEY_CREATE_INFO *key_info_arg, + In_C_you_should_use_my_bool_instead() generated_arg, List<Key_part_spec> &cols) + :type(type_par), key_create_info(*key_info_arg), columns(cols), + name(name_arg), generated(generated_arg) + {} + Key(const Key &rhs, MEM_ROOT *mem_root); + virtual ~Key() {} + friend In_C_you_should_use_my_bool_instead() foreign_key_prefix(Key *a, Key *b); + virtual Key *clone(MEM_ROOT *mem_root) const + { return new (mem_root) Key(*this, mem_root); } +}; +class Table_ident; +class Foreign_key: public Key { +public: + enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL, + FK_MATCH_PARTIAL, FK_MATCH_SIMPLE}; + enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE, + FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT}; + Table_ident *ref_table; + List<Key_part_spec> ref_columns; + uint delete_opt, update_opt, match_opt; + Foreign_key(const char *name_arg, List<Key_part_spec> &cols, + Table_ident *table, List<Key_part_spec> &ref_cols, + uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg) + :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols), + ref_table(table), ref_columns(ref_cols), + delete_opt(delete_opt_arg), update_opt(update_opt_arg), + match_opt(match_opt_arg) + {} + Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root); + virtual Key *clone(MEM_ROOT *mem_root) const + { return new (mem_root) Foreign_key(*this, mem_root); } +}; +typedef struct st_mysql_lock +{ + TABLE **table; + uint table_count,lock_count; + THR_LOCK_DATA **locks; +} MYSQL_LOCK; +class LEX_COLUMN : public Sql_alloc +{ +public: + String column; + uint rights; + LEX_COLUMN (const String& x,const uint& y ): column (x),rights (y) {} +}; +#include "sql_lex.h" +class Table_ident; +class sql_exchange; +class LEX_COLUMN; +class sp_head; +class sp_name; +class sp_instr; +class sp_pcontext; +class st_alter_tablespace; +class partition_info; +class Event_parse_data; +enum enum_sql_command { + SQLCOM_SELECT, SQLCOM_CREATE_TABLE, SQLCOM_CREATE_INDEX, SQLCOM_ALTER_TABLE, + SQLCOM_UPDATE, SQLCOM_INSERT, SQLCOM_INSERT_SELECT, + SQLCOM_DELETE, SQLCOM_TRUNCATE, SQLCOM_DROP_TABLE, SQLCOM_DROP_INDEX, + SQLCOM_SHOW_DATABASES, SQLCOM_SHOW_TABLES, SQLCOM_SHOW_FIELDS, + SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_STATUS, + SQLCOM_SHOW_ENGINE_LOGS, SQLCOM_SHOW_ENGINE_STATUS, SQLCOM_SHOW_ENGINE_MUTEX, + SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT, + SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS, + SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS, + SQLCOM_SHOW_TRIGGERS, + SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES, + SQLCOM_GRANT, + SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB, + SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT, + SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION, + SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK, + SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS, + SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE, + SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT, + SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT, + SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP, + SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER, + SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE, + SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS, + SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA, + SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ, + SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI, + SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO, + SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS, + SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES, + SQLCOM_HELP, SQLCOM_CREATE_USER, SQLCOM_DROP_USER, SQLCOM_RENAME_USER, + SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM, + SQLCOM_CREATE_PROCEDURE, SQLCOM_CREATE_SPFUNCTION, SQLCOM_CALL, + SQLCOM_DROP_PROCEDURE, SQLCOM_ALTER_PROCEDURE,SQLCOM_ALTER_FUNCTION, + SQLCOM_SHOW_CREATE_PROC, SQLCOM_SHOW_CREATE_FUNC, + SQLCOM_SHOW_STATUS_PROC, SQLCOM_SHOW_STATUS_FUNC, + SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE, + SQLCOM_CREATE_VIEW, SQLCOM_DROP_VIEW, + SQLCOM_CREATE_TRIGGER, SQLCOM_DROP_TRIGGER, + SQLCOM_XA_START, SQLCOM_XA_END, SQLCOM_XA_PREPARE, + SQLCOM_XA_COMMIT, SQLCOM_XA_ROLLBACK, SQLCOM_XA_RECOVER, + SQLCOM_SHOW_PROC_CODE, SQLCOM_SHOW_FUNC_CODE, + SQLCOM_ALTER_TABLESPACE, + SQLCOM_INSTALL_PLUGIN, SQLCOM_UNINSTALL_PLUGIN, + SQLCOM_SHOW_AUTHORS, SQLCOM_BINLOG_BASE64_EVENT, + SQLCOM_SHOW_PLUGINS, + SQLCOM_SHOW_CONTRIBUTORS, + SQLCOM_CREATE_SERVER, SQLCOM_DROP_SERVER, SQLCOM_ALTER_SERVER, + SQLCOM_CREATE_EVENT, SQLCOM_ALTER_EVENT, SQLCOM_DROP_EVENT, + SQLCOM_SHOW_CREATE_EVENT, SQLCOM_SHOW_EVENTS, + SQLCOM_SHOW_CREATE_TRIGGER, + SQLCOM_ALTER_DB_UPGRADE, + SQLCOM_SHOW_PROFILE, SQLCOM_SHOW_PROFILES, + SQLCOM_END +}; +class Delayed_insert; +class select_result; +class Time_zone; +struct system_variables +{ + ulong dynamic_variables_version; + char* dynamic_variables_ptr; + uint dynamic_variables_head; + uint dynamic_variables_size; + ulonglong myisam_max_extra_sort_file_size; + ulonglong myisam_max_sort_file_size; + ulonglong max_heap_table_size; + ulonglong tmp_table_size; + ulonglong long_query_time; + ha_rows select_limit; + ha_rows max_join_size; + ulong auto_increment_increment, auto_increment_offset; + ulong bulk_insert_buff_size; + ulong join_buff_size; + ulong max_allowed_packet; + ulong max_error_count; + ulong max_length_for_sort_data; + ulong max_sort_length; + ulong max_tmp_tables; + ulong max_insert_delayed_threads; + ulong min_examined_row_limit; + ulong multi_range_count; + ulong myisam_repair_threads; + ulong myisam_sort_buff_size; + ulong myisam_stats_method; + ulong net_buffer_length; + ulong net_interactive_timeout; + ulong net_read_timeout; + ulong net_retry_count; + ulong net_wait_timeout; + ulong net_write_timeout; + ulong optimizer_prune_level; + ulong optimizer_search_depth; + ulong preload_buff_size; + ulong profiling_history_size; + ulong query_cache_type; + ulong read_buff_size; + ulong read_rnd_buff_size; + ulong div_precincrement; + ulong sortbuff_size; + ulong thread_handling; + ulong tx_isolation; + ulong completion_type; + ulong sql_mode; + ulong max_sp_recursion_depth; + ulong updatable_views_with_limit; + ulong default_week_format; + ulong max_seeks_for_key; + ulong range_alloc_block_size; + ulong query_alloc_block_size; + ulong query_prealloc_size; + ulong trans_alloc_block_size; + ulong trans_prealloc_size; + ulong log_warnings; + ulong group_concat_max_len; + ulong ndb_autoincrement_prefetch_sz; + ulong ndb_index_stat_cache_entries; + ulong ndb_index_stat_update_freq; + ulong binlog_format; + my_thread_id pseudo_thread_id; + my_bool low_priority_updates; + my_bool new_mode; + my_bool old_mode; + my_bool query_cache_wlock_invalidate; + my_bool engine_condition_pushdown; + my_bool keep_files_on_create; + my_bool ndb_force_send; + my_bool ndb_use_copying_alter_table; + my_bool ndb_use_exact_count; + my_bool ndb_use_transactions; + my_bool ndb_index_stat_enable; + my_bool old_alter_table; + my_bool old_passwords; + plugin_ref table_plugin; + CHARSET_INFO *character_set_filesystem; + CHARSET_INFO *character_set_client; + CHARSET_INFO *character_set_results; + CHARSET_INFO *collation_server; + CHARSET_INFO *collation_database; + CHARSET_INFO *collation_connection; + MY_LOCALE *lc_time_names; + Time_zone *time_zone; + DATE_TIME_FORMAT *date_format; + DATE_TIME_FORMAT *datetime_format; + DATE_TIME_FORMAT *time_format; + my_bool sysdate_is_now; +}; +typedef struct system_status_var +{ + ulonglong bytes_received; + ulonglong bytes_sent; + ulong com_other; + ulong com_stat[(uint) SQLCOM_END]; + ulong created_tmp_disk_tables; + ulong created_tmp_tables; + ulong ha_commit_count; + ulong ha_delete_count; + ulong ha_read_first_count; + ulong ha_read_last_count; + ulong ha_read_key_count; + ulong ha_read_next_count; + ulong ha_read_prev_count; + ulong ha_read_rnd_count; + ulong ha_read_rnd_next_count; + ulong ha_rollback_count; + ulong ha_update_count; + ulong ha_write_count; + ulong ha_prepare_count; + ulong ha_discover_count; + ulong ha_savepoint_count; + ulong ha_savepoint_rollback_count; + ulong key_blocks_changed; + ulong key_blocks_used; + ulong key_cache_r_requests; + ulong key_cache_read; + ulong key_cache_w_requests; + ulong key_cache_write; + ulong net_big_packet_count; + ulong opened_tables; + ulong opened_shares; + ulong select_full_join_count; + ulong select_full_range_join_count; + ulong select_range_count; + ulong select_range_check_count; + ulong select_scan_count; + ulong long_query_count; + ulong filesort_merge_passes; + ulong filesort_range_count; + ulong filesort_rows; + ulong filesort_scan_count; + ulong com_stmt_prepare; + ulong com_stmt_reprepare; + ulong com_stmt_execute; + ulong com_stmt_send_long_data; + ulong com_stmt_fetch; + ulong com_stmt_reset; + ulong com_stmt_close; + double last_query_cost; +} STATUS_VAR; +void mark_transaction_to_rollback(THD *thd, In_C_you_should_use_my_bool_instead() all); +#include "sql_acl.h" +#include "slave.h" +#include "log.h" +#include "my_list.h" +#include "rpl_filter.h" +#include "mysql.h" +#include "mysql_version.h" +#include "mysql_com.h" +#include "mysql_time.h" +#include "my_list.h" +extern unsigned int mysql_port; +extern char *mysql_unix_port; +typedef struct st_mysql_field { + char *name; + char *org_name; + char *table; + char *org_table; + char *db; + char *catalog; + char *def; + unsigned long length; + unsigned long max_length; + 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; + unsigned int decimals; + unsigned int charsetnr; + enum enum_field_types type; + void *extension; +} MYSQL_FIELD; +typedef char **MYSQL_ROW; +typedef unsigned int MYSQL_FIELD_OFFSET; +#include "typelib.h" +typedef struct st_mysql_rows { + struct st_mysql_rows *next; + MYSQL_ROW data; + unsigned long length; +} MYSQL_ROWS; +typedef MYSQL_ROWS *MYSQL_ROW_OFFSET; +#include "my_alloc.h" +typedef struct embedded_query_result EMBEDDED_QUERY_RESULT; +typedef struct st_mysql_data { + MYSQL_ROWS *data; + struct embedded_query_result *embedded_info; + MEM_ROOT alloc; + my_ulonglong rows; + unsigned int fields; + void *extension; +} 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, + MYSQL_OPT_SSL_VERIFY_SERVER_CERT +}; +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; + char *ssl_cert; + char *ssl_ca; + char *ssl_capath; + char *ssl_cipher; + char *shared_memory_base_name; + unsigned long max_allowed_packet; + my_bool use_ssl; + my_bool compress,named_pipe; + my_bool rpl_probe; + my_bool rpl_parse; + my_bool no_master_reads; + my_bool separate_thread; + enum mysql_option methods_to_use; + char *client_ip; + my_bool secure_auth; + my_bool report_data_truncation; + 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; + void *extension; +}; +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 +}; +enum mysql_rpl_type +{ + MYSQL_RPL_MASTER, MYSQL_RPL_SLAVE, MYSQL_RPL_ADMIN +}; +typedef struct character_set +{ + unsigned int number; + unsigned int state; + const char *csname; + const char *name; + const char *comment; + const char *dir; + unsigned int mbminlen; + unsigned int mbmaxlen; +} MY_CHARSET_INFO; +struct st_mysql_methods; +struct st_mysql_stmt; +typedef struct st_mysql +{ + NET net; + unsigned char *connector_fd; + char *host,*user,*passwd,*unix_socket,*server_version,*host_info; + char *info, *db; + struct charset_info_st *charset; + MYSQL_FIELD *fields; + MEM_ROOT field_alloc; + my_ulonglong affected_rows; + my_ulonglong insert_id; + my_ulonglong extra_info; + unsigned long thread_id; + 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; + my_bool reconnect; + char scramble[20 +1]; + my_bool rpl_pivot; + struct st_mysql* master, *next_slave; + struct st_mysql* last_used_slave; + struct st_mysql* last_used_con; + LIST *stmts; + const struct st_mysql_methods *methods; + void *thd; + my_bool *unbuffered_fetch_owner; + char *info_buffer; + void *extension; +} MYSQL; +typedef struct st_mysql_res { + my_ulonglong row_count; + MYSQL_FIELD *fields; + MYSQL_DATA *data; + MYSQL_ROWS *data_cursor; + unsigned long *lengths; + MYSQL *handle; + const struct st_mysql_methods *methods; + MYSQL_ROW row; + MYSQL_ROW current_row; + MEM_ROOT field_alloc; + unsigned int field_count, current_field; + my_bool eof; + my_bool unbuffered_fetch_cancelled; + void *extension; +} MYSQL_RES; +typedef struct st_mysql_manager +{ + NET net; + char *host, *user, *passwd; + char *net_buf, *net_buf_pos, *net_data_end; + unsigned int port; + int cmd_status; + int last_errno; + int net_buf_size; + my_bool free_me; + my_bool eof; + char last_error[256]; + void *extension; +} MYSQL_MANAGER; +typedef struct st_mysql_parameters +{ + unsigned long *p_max_allowed_packet; + unsigned long *p_net_buffer_length; + void *extension; +} MYSQL_PARAMETERS; +int mysql_server_init(int argc, char **argv, char **groups); +void mysql_server_end(void); +MYSQL_PARAMETERS * mysql_get_parameters(void); +my_bool mysql_thread_init(void); +void mysql_thread_end(void); +my_ulonglong mysql_num_rows(MYSQL_RES *res); +unsigned int mysql_num_fields(MYSQL_RES *res); +my_bool mysql_eof(MYSQL_RES *res); +MYSQL_FIELD * mysql_fetch_field_direct(MYSQL_RES *res, + unsigned int fieldnr); +MYSQL_FIELD * mysql_fetch_fields(MYSQL_RES *res); +MYSQL_ROW_OFFSET mysql_row_tell(MYSQL_RES *res); +MYSQL_FIELD_OFFSET mysql_field_tell(MYSQL_RES *res); +unsigned int mysql_field_count(MYSQL *mysql); +my_ulonglong mysql_affected_rows(MYSQL *mysql); +my_ulonglong mysql_insert_id(MYSQL *mysql); +unsigned int mysql_errno(MYSQL *mysql); +const char * mysql_error(MYSQL *mysql); +const char * mysql_sqlstate(MYSQL *mysql); +unsigned int mysql_warning_count(MYSQL *mysql); +const char * mysql_info(MYSQL *mysql); +unsigned long mysql_thread_id(MYSQL *mysql); +const char * mysql_character_set_name(MYSQL *mysql); +int mysql_set_character_set(MYSQL *mysql, const char *csname); +MYSQL * mysql_init(MYSQL *mysql); +my_bool mysql_ssl_set(MYSQL *mysql, const char *key, + const char *cert, const char *ca, + const char *capath, const char *cipher); +const char * mysql_get_ssl_cipher(MYSQL *mysql); +my_bool mysql_change_user(MYSQL *mysql, const char *user, + const char *passwd, const char *db); +MYSQL * 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 mysql_select_db(MYSQL *mysql, const char *db); +int mysql_query(MYSQL *mysql, const char *q); +int mysql_send_query(MYSQL *mysql, const char *q, + unsigned long length); +int mysql_real_query(MYSQL *mysql, const char *q, + unsigned long length); +MYSQL_RES * mysql_store_result(MYSQL *mysql); +MYSQL_RES * mysql_use_result(MYSQL *mysql); +my_bool mysql_master_query(MYSQL *mysql, const char *q, + unsigned long length); +my_bool mysql_master_send_query(MYSQL *mysql, const char *q, + unsigned long length); +my_bool mysql_slave_query(MYSQL *mysql, const char *q, + unsigned long length); +my_bool mysql_slave_send_query(MYSQL *mysql, const char *q, + unsigned long length); +void mysql_get_character_set_info(MYSQL *mysql, + MY_CHARSET_INFO *charset); +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); +void mysql_enable_rpl_parse(MYSQL* mysql); +void mysql_disable_rpl_parse(MYSQL* mysql); +int mysql_rpl_parse_enabled(MYSQL* mysql); +void mysql_enable_reads_from_master(MYSQL* mysql); +void mysql_disable_reads_from_master(MYSQL* mysql); +my_bool mysql_reads_from_master_enabled(MYSQL* mysql); +enum mysql_rpl_type mysql_rpl_query_type(const char* q, int len); +my_bool mysql_rpl_probe(MYSQL* mysql); +int mysql_set_master(MYSQL* mysql, const char* host, + unsigned int port, + const char* user, + const char* passwd); +int mysql_add_slave(MYSQL* mysql, const char* host, + unsigned int port, + const char* user, + const char* passwd); +int mysql_shutdown(MYSQL *mysql, + enum mysql_enum_shutdown_level + shutdown_level); +int mysql_dump_debug_info(MYSQL *mysql); +int mysql_refresh(MYSQL *mysql, + unsigned int refresh_options); +int mysql_kill(MYSQL *mysql,unsigned long pid); +int mysql_set_server_option(MYSQL *mysql, + enum enum_mysql_set_option + option); +int mysql_ping(MYSQL *mysql); +const char * mysql_stat(MYSQL *mysql); +const char * mysql_get_server_info(MYSQL *mysql); +const char * mysql_get_client_info(void); +unsigned long mysql_get_client_version(void); +const char * mysql_get_host_info(MYSQL *mysql); +unsigned long mysql_get_server_version(MYSQL *mysql); +unsigned int mysql_get_proto_info(MYSQL *mysql); +MYSQL_RES * mysql_list_dbs(MYSQL *mysql,const char *wild); +MYSQL_RES * mysql_list_tables(MYSQL *mysql,const char *wild); +MYSQL_RES * mysql_list_processes(MYSQL *mysql); +int mysql_options(MYSQL *mysql,enum mysql_option option, + const void *arg); +void mysql_free_result(MYSQL_RES *result); +void mysql_data_seek(MYSQL_RES *result, + my_ulonglong offset); +MYSQL_ROW_OFFSET mysql_row_seek(MYSQL_RES *result, + MYSQL_ROW_OFFSET offset); +MYSQL_FIELD_OFFSET mysql_field_seek(MYSQL_RES *result, + MYSQL_FIELD_OFFSET offset); +MYSQL_ROW mysql_fetch_row(MYSQL_RES *result); +unsigned long * mysql_fetch_lengths(MYSQL_RES *result); +MYSQL_FIELD * mysql_fetch_field(MYSQL_RES *result); +MYSQL_RES * mysql_list_fields(MYSQL *mysql, const char *table, + const char *wild); +unsigned long mysql_escape_string(char *to,const char *from, + unsigned long from_length); +unsigned long mysql_hex_string(char *to,const char *from, + unsigned long from_length); +unsigned long mysql_real_escape_string(MYSQL *mysql, + char *to,const char *from, + unsigned long length); +void mysql_debug(const char *debug); +void myodbc_remove_escape(MYSQL *mysql,char *name); +unsigned int mysql_thread_safe(void); +my_bool mysql_embedded(void); +MYSQL_MANAGER* mysql_manager_init(MYSQL_MANAGER* con); +MYSQL_MANAGER* mysql_manager_connect(MYSQL_MANAGER* con, + const char* host, + const char* user, + const char* passwd, + unsigned int port); +void mysql_manager_close(MYSQL_MANAGER* con); +int mysql_manager_command(MYSQL_MANAGER* con, + const char* cmd, int cmd_len); +int mysql_manager_fetch_line(MYSQL_MANAGER* con, + char* res_buf, + int res_buf_size); +my_bool mysql_read_query_result(MYSQL *mysql); +enum enum_mysql_stmt_state +{ + MYSQL_STMT_INIT_DONE= 1, MYSQL_STMT_PREPARE_DONE, MYSQL_STMT_EXECUTE_DONE, + MYSQL_STMT_FETCH_DONE +}; +typedef struct st_mysql_bind +{ + unsigned long *length; + my_bool *is_null; + void *buffer; + my_bool *error; + unsigned char *row_ptr; + 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); + unsigned long buffer_length; + unsigned long offset; + unsigned long length_value; + unsigned int param_number; + unsigned int pack_length; + enum enum_field_types buffer_type; + my_bool error_value; + my_bool is_unsigned; + my_bool long_data_used; + my_bool is_null_value; + void *extension; +} MYSQL_BIND; +typedef struct st_mysql_stmt +{ + MEM_ROOT mem_root; + LIST list; + MYSQL *mysql; + MYSQL_BIND *params; + MYSQL_BIND *bind; + MYSQL_FIELD *fields; + MYSQL_DATA result; + MYSQL_ROWS *data_cursor; + int (*read_row_func)(struct st_mysql_stmt *stmt, + unsigned char **row); + my_ulonglong affected_rows; + my_ulonglong insert_id; + unsigned long stmt_id; + unsigned long flags; + unsigned long prefetch_rows; + unsigned int server_status; + unsigned int last_errno; + unsigned int param_count; + unsigned int field_count; + enum enum_mysql_stmt_state state; + char last_error[512]; + char sqlstate[5 +1]; + my_bool send_types_to_server; + my_bool bind_param_done; + unsigned char bind_result_done; + my_bool unbuffered_fetch_cancelled; + my_bool update_max_length; + void *extension; +} MYSQL_STMT; +enum enum_stmt_attr_type +{ + STMT_ATTR_UPDATE_MAX_LENGTH, + STMT_ATTR_CURSOR_TYPE, + 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 unsigned char *header, + unsigned long header_length, + const unsigned char *arg, + unsigned long arg_length, + my_bool skip_check, + MYSQL_STMT *stmt); + 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); + 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); + int (*read_rows_from_cursor)(MYSQL_STMT *stmt); +} MYSQL_METHODS; +MYSQL_STMT * mysql_stmt_init(MYSQL *mysql); +int mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, + unsigned long length); +int mysql_stmt_execute(MYSQL_STMT *stmt); +int mysql_stmt_fetch(MYSQL_STMT *stmt); +int mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind_arg, + unsigned int column, + unsigned long offset); +int mysql_stmt_store_result(MYSQL_STMT *stmt); +unsigned long mysql_stmt_param_count(MYSQL_STMT * stmt); +my_bool mysql_stmt_attr_set(MYSQL_STMT *stmt, + enum enum_stmt_attr_type attr_type, + const void *attr); +my_bool mysql_stmt_attr_get(MYSQL_STMT *stmt, + enum enum_stmt_attr_type attr_type, + void *attr); +my_bool mysql_stmt_bind_param(MYSQL_STMT * stmt, MYSQL_BIND * bnd); +my_bool mysql_stmt_bind_result(MYSQL_STMT * stmt, MYSQL_BIND * bnd); +my_bool mysql_stmt_close(MYSQL_STMT * stmt); +my_bool mysql_stmt_reset(MYSQL_STMT * stmt); +my_bool mysql_stmt_free_result(MYSQL_STMT *stmt); +my_bool mysql_stmt_send_long_data(MYSQL_STMT *stmt, + unsigned int param_number, + const char *data, + unsigned long length); +MYSQL_RES * mysql_stmt_result_metadata(MYSQL_STMT *stmt); +MYSQL_RES * mysql_stmt_param_metadata(MYSQL_STMT *stmt); +unsigned int mysql_stmt_errno(MYSQL_STMT * stmt); +const char * mysql_stmt_error(MYSQL_STMT * stmt); +const char * mysql_stmt_sqlstate(MYSQL_STMT * stmt); +MYSQL_ROW_OFFSET mysql_stmt_row_seek(MYSQL_STMT *stmt, + MYSQL_ROW_OFFSET offset); +MYSQL_ROW_OFFSET mysql_stmt_row_tell(MYSQL_STMT *stmt); +void mysql_stmt_data_seek(MYSQL_STMT *stmt, my_ulonglong offset); +my_ulonglong mysql_stmt_num_rows(MYSQL_STMT *stmt); +my_ulonglong mysql_stmt_affected_rows(MYSQL_STMT *stmt); +my_ulonglong mysql_stmt_insert_id(MYSQL_STMT *stmt); +unsigned int mysql_stmt_field_count(MYSQL_STMT *stmt); +my_bool mysql_commit(MYSQL * mysql); +my_bool mysql_rollback(MYSQL * mysql); +my_bool mysql_autocommit(MYSQL * mysql, my_bool auto_mode); +my_bool mysql_more_results(MYSQL *mysql); +int mysql_next_result(MYSQL *mysql); +void mysql_close(MYSQL *sock); +typedef struct st_table_rule_ent +{ + char* db; + char* tbl_name; + uint key_len; +} TABLE_RULE_ENT; +class Rpl_filter +{ +public: + Rpl_filter(); + ~Rpl_filter(); + Rpl_filter(Rpl_filter const&); + Rpl_filter& operator=(Rpl_filter const&); + In_C_you_should_use_my_bool_instead() tables_ok(const char* db, TABLE_LIST* tables); + In_C_you_should_use_my_bool_instead() db_ok(const char* db); + In_C_you_should_use_my_bool_instead() db_ok_with_wild_table(const char *db); + In_C_you_should_use_my_bool_instead() is_on(); + int add_do_table(const char* table_spec); + int add_ignore_table(const char* table_spec); + int add_wild_do_table(const char* table_spec); + int add_wild_ignore_table(const char* table_spec); + void add_do_db(const char* db_spec); + void add_ignore_db(const char* db_spec); + void add_db_rewrite(const char* from_db, const char* to_db); + void get_do_table(String* str); + void get_ignore_table(String* str); + void get_wild_do_table(String* str); + void get_wild_ignore_table(String* str); + const char* get_rewrite_db(const char* db, size_t *new_len); + I_List<i_string>* get_do_db(); + I_List<i_string>* get_ignore_db(); +private: + In_C_you_should_use_my_bool_instead() table_rules_on; + void init_table_rule_hash(HASH* h, In_C_you_should_use_my_bool_instead()* h_inited); + void init_table_rule_array(DYNAMIC_ARRAY* a, In_C_you_should_use_my_bool_instead()* a_inited); + int add_table_rule(HASH* h, const char* table_spec); + int add_wild_table_rule(DYNAMIC_ARRAY* a, const char* table_spec); + void free_string_array(DYNAMIC_ARRAY *a); + void table_rule_ent_hash_to_str(String* s, HASH* h, In_C_you_should_use_my_bool_instead() inited); + void table_rule_ent_dynamic_array_to_str(String* s, DYNAMIC_ARRAY* a, + In_C_you_should_use_my_bool_instead() inited); + TABLE_RULE_ENT* find_wild(DYNAMIC_ARRAY *a, const char* key, int len); + HASH do_table; + HASH ignore_table; + DYNAMIC_ARRAY wild_do_table; + DYNAMIC_ARRAY wild_ignore_table; + In_C_you_should_use_my_bool_instead() do_table_inited; + In_C_you_should_use_my_bool_instead() ignore_table_inited; + In_C_you_should_use_my_bool_instead() wild_do_table_inited; + In_C_you_should_use_my_bool_instead() wild_ignore_table_inited; + I_List<i_string> do_db; + I_List<i_string> ignore_db; + I_List<i_string_pair> rewrite_db; +}; +extern Rpl_filter *rpl_filter; +extern Rpl_filter *binlog_filter; +#include "rpl_tblmap.h" +class Relay_log_info; +class Master_info; +extern ulong master_retry_count; +extern MY_BITMAP slave_error_mask; +extern In_C_you_should_use_my_bool_instead() use_slave_mask; +extern char *slave_load_tmpdir; +extern char *master_info_file, *relay_log_info_file; +extern char *opt_relay_logname, *opt_relaylog_index_name; +extern my_bool opt_skip_slave_start, opt_reckless_slave; +extern my_bool opt_log_slave_updates; +extern ulonglong relay_log_space_limit; +int init_slave(); +void init_slave_skip_errors(const char* arg); +In_C_you_should_use_my_bool_instead() flush_relay_log_info(Relay_log_info* rli); +int register_slave_on_master(MYSQL* mysql); +int terminate_slave_threads(Master_info* mi, int thread_mask, + In_C_you_should_use_my_bool_instead() skip_lock = 0); +int start_slave_threads(In_C_you_should_use_my_bool_instead() need_slave_mutex, In_C_you_should_use_my_bool_instead() wait_for_start, + Master_info* mi, const char* master_info_fname, + const char* slave_info_fname, int thread_mask); +int start_slave_thread(pthread_handler h_func, pthread_mutex_t* start_lock, + pthread_mutex_t *cond_lock, + pthread_cond_t* start_cond, + volatile uint *slave_running, + volatile ulong *slave_run_id, + Master_info* mi, + In_C_you_should_use_my_bool_instead() high_priority); +int mysql_table_dump(THD* thd, const char* db, + const char* tbl_name, int fd = -1); +int fetch_master_table(THD* thd, const char* db_name, const char* table_name, + Master_info* mi, MYSQL* mysql, In_C_you_should_use_my_bool_instead() overwrite); +In_C_you_should_use_my_bool_instead() show_master_info(THD* thd, Master_info* mi); +In_C_you_should_use_my_bool_instead() show_binlog_info(THD* thd); +In_C_you_should_use_my_bool_instead() rpl_master_has_bug(Relay_log_info *rli, uint bug_id, In_C_you_should_use_my_bool_instead() report=(1)); +In_C_you_should_use_my_bool_instead() rpl_master_erroneous_autoinc(THD* thd); +const char *print_slave_db_safe(const char *db); +int check_expected_error(THD* thd, Relay_log_info const *rli, int error_code); +void skip_load_data_infile(NET* net); +void end_slave(); +void clear_until_condition(Relay_log_info* rli); +void clear_slave_error(Relay_log_info* rli); +void end_relay_log_info(Relay_log_info* rli); +void lock_slave_threads(Master_info* mi); +void unlock_slave_threads(Master_info* mi); +void init_thread_mask(int* mask,Master_info* mi,In_C_you_should_use_my_bool_instead() inverse); +int init_relay_log_pos(Relay_log_info* rli,const char* log,ulonglong pos, + In_C_you_should_use_my_bool_instead() need_data_lock, const char** errmsg, + In_C_you_should_use_my_bool_instead() look_for_description_event); +int purge_relay_logs(Relay_log_info* rli, THD *thd, In_C_you_should_use_my_bool_instead() just_reset, + const char** errmsg); +void set_slave_thread_options(THD* thd); +void set_slave_thread_default_charset(THD *thd, Relay_log_info const *rli); +void rotate_relay_log(Master_info* mi); +int apply_event_and_update_pos(Log_event* ev, THD* thd, Relay_log_info* rli, + In_C_you_should_use_my_bool_instead() skip); + void * handle_slave_io(void *arg); + void * handle_slave_sql(void *arg); +extern In_C_you_should_use_my_bool_instead() volatile abort_loop; +extern Master_info main_mi, *active_mi; +extern LIST master_list; +extern my_bool replicate_same_server_id; +extern int disconnect_slave_event_count, abort_slave_event_count ; +extern uint master_port, master_connect_retry, report_port; +extern char * master_user, *master_password, *master_host; +extern char *master_info_file, *relay_log_info_file, *report_user; +extern char *report_host, *report_password; +extern my_bool master_ssl; +extern char *master_ssl_ca, *master_ssl_capath, *master_ssl_cert; +extern char *master_ssl_cipher, *master_ssl_key; +extern I_List<THD> threads; +enum mysql_db_table_field +{ + MYSQL_DB_FIELD_HOST = 0, + MYSQL_DB_FIELD_DB, + MYSQL_DB_FIELD_USER, + MYSQL_DB_FIELD_SELECT_PRIV, + MYSQL_DB_FIELD_INSERT_PRIV, + MYSQL_DB_FIELD_UPDATE_PRIV, + MYSQL_DB_FIELD_DELETE_PRIV, + MYSQL_DB_FIELD_CREATE_PRIV, + MYSQL_DB_FIELD_DROP_PRIV, + MYSQL_DB_FIELD_GRANT_PRIV, + MYSQL_DB_FIELD_REFERENCES_PRIV, + MYSQL_DB_FIELD_INDEX_PRIV, + MYSQL_DB_FIELD_ALTER_PRIV, + MYSQL_DB_FIELD_CREATE_TMP_TABLE_PRIV, + MYSQL_DB_FIELD_LOCK_TABLES_PRIV, + MYSQL_DB_FIELD_CREATE_VIEW_PRIV, + MYSQL_DB_FIELD_SHOW_VIEW_PRIV, + MYSQL_DB_FIELD_CREATE_ROUTINE_PRIV, + MYSQL_DB_FIELD_ALTER_ROUTINE_PRIV, + MYSQL_DB_FIELD_EXECUTE_PRIV, + MYSQL_DB_FIELD_EVENT_PRIV, + MYSQL_DB_FIELD_TRIGGER_PRIV, + MYSQL_DB_FIELD_COUNT +}; +extern TABLE_FIELD_W_TYPE mysql_db_table_fields[]; +extern time_t mysql_db_table_last_check; +struct acl_host_and_ip +{ + char *hostname; + long ip,ip_mask; +}; +class ACL_ACCESS { +public: + ulong sort; + ulong access; +}; +class ACL_HOST :public ACL_ACCESS +{ +public: + acl_host_and_ip host; + char *db; +}; +class ACL_USER :public ACL_ACCESS +{ +public: + acl_host_and_ip host; + uint hostname_length; + USER_RESOURCES user_resource; + char *user; + uint8 salt[20 +1]; + uint8 salt_len; + enum SSL_type ssl_type; + const char *ssl_cipher, *x509_issuer, *x509_subject; +}; +class ACL_DB :public ACL_ACCESS +{ +public: + acl_host_and_ip host; + char *user,*db; +}; +In_C_you_should_use_my_bool_instead() hostname_requires_resolving(const char *hostname); +my_bool acl_init(In_C_you_should_use_my_bool_instead() dont_read_acl_tables); +my_bool acl_reload(THD *thd); +void acl_free(In_C_you_should_use_my_bool_instead() end=0); +ulong acl_get(const char *host, const char *ip, + const char *user, const char *db, my_bool db_is_pattern); +int acl_getroot(THD *thd, USER_RESOURCES *mqh, const char *passwd, + uint passwd_len); +In_C_you_should_use_my_bool_instead() acl_getroot_no_password(Security_context *sctx, char *user, char *host, + char *ip, char *db); +In_C_you_should_use_my_bool_instead() acl_check_host(const char *host, const char *ip); +int check_change_password(THD *thd, const char *host, const char *user, + char *password, uint password_len); +In_C_you_should_use_my_bool_instead() change_password(THD *thd, const char *host, const char *user, + char *password); +In_C_you_should_use_my_bool_instead() mysql_grant(THD *thd, const char *db, List <LEX_USER> &user_list, + ulong rights, In_C_you_should_use_my_bool_instead() revoke); +int mysql_table_grant(THD *thd, TABLE_LIST *table, List <LEX_USER> &user_list, + List <LEX_COLUMN> &column_list, ulong rights, + In_C_you_should_use_my_bool_instead() revoke); +In_C_you_should_use_my_bool_instead() mysql_routine_grant(THD *thd, TABLE_LIST *table, In_C_you_should_use_my_bool_instead() is_proc, + List <LEX_USER> &user_list, ulong rights, + In_C_you_should_use_my_bool_instead() revoke, In_C_you_should_use_my_bool_instead() no_error); +my_bool grant_init(); +void grant_free(void); +my_bool grant_reload(THD *thd); +In_C_you_should_use_my_bool_instead() check_grant(THD *thd, ulong want_access, TABLE_LIST *tables, + uint show_command, uint number, In_C_you_should_use_my_bool_instead() dont_print_error); +In_C_you_should_use_my_bool_instead() check_grant_column (THD *thd, GRANT_INFO *grant, + const char *db_name, const char *table_name, + const char *name, uint length, Security_context *sctx); +In_C_you_should_use_my_bool_instead() check_column_grant_in_table_ref(THD *thd, TABLE_LIST * table_ref, + const char *name, uint length); +In_C_you_should_use_my_bool_instead() check_grant_all_columns(THD *thd, ulong want_access, + Field_iterator_table_ref *fields); +In_C_you_should_use_my_bool_instead() check_grant_routine(THD *thd, ulong want_access, + TABLE_LIST *procs, In_C_you_should_use_my_bool_instead() is_proc, In_C_you_should_use_my_bool_instead() no_error); +In_C_you_should_use_my_bool_instead() check_grant_db(THD *thd,const char *db); +ulong get_table_grant(THD *thd, TABLE_LIST *table); +ulong get_column_grant(THD *thd, GRANT_INFO *grant, + const char *db_name, const char *table_name, + const char *field_name); +In_C_you_should_use_my_bool_instead() mysql_show_grants(THD *thd, LEX_USER *user); +void get_privilege_desc(char *to, uint max_length, ulong access); +void get_mqh(const char *user, const char *host, USER_CONN *uc); +In_C_you_should_use_my_bool_instead() mysql_create_user(THD *thd, List <LEX_USER> &list); +In_C_you_should_use_my_bool_instead() mysql_drop_user(THD *thd, List <LEX_USER> &list); +In_C_you_should_use_my_bool_instead() mysql_rename_user(THD *thd, List <LEX_USER> &list); +In_C_you_should_use_my_bool_instead() mysql_revoke_all(THD *thd, List <LEX_USER> &list); +void fill_effective_table_privileges(THD *thd, GRANT_INFO *grant, + const char *db, const char *table); +In_C_you_should_use_my_bool_instead() sp_revoke_privileges(THD *thd, const char *sp_db, const char *sp_name, + In_C_you_should_use_my_bool_instead() is_proc); +int sp_grant_privileges(THD *thd, const char *sp_db, const char *sp_name, + In_C_you_should_use_my_bool_instead() is_proc); +In_C_you_should_use_my_bool_instead() check_routine_level_acl(THD *thd, const char *db, const char *name, + In_C_you_should_use_my_bool_instead() is_proc); +In_C_you_should_use_my_bool_instead() is_acl_user(const char *host, const char *user); +#include "tztime.h" +class Time_zone: public Sql_alloc +{ +public: + Time_zone() {} + virtual my_time_t TIME_to_gmt_sec(const MYSQL_TIME *t, + my_bool *in_dst_time_gap) const = 0; + virtual void gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const = 0; + virtual const String * get_name() const = 0; + virtual ~Time_zone() {}; +}; +extern Time_zone * my_tz_UTC; +extern Time_zone * my_tz_SYSTEM; +extern Time_zone * my_tz_OFFSET0; +extern Time_zone * my_tz_find(THD *thd, const String *name); +extern my_bool my_tz_init(THD *org_thd, const char *default_tzname, my_bool bootstrap); +extern void my_tz_free(); +extern my_time_t sec_since_epoch_TIME(MYSQL_TIME *t); +static const int MY_TZ_TABLES_COUNT= 4; +In_C_you_should_use_my_bool_instead() check_global_access(THD *thd, ulong want_access); +int get_quote_char_for_identifier(THD *thd, const char *name, uint length); +void sql_perror(const char *message); +In_C_you_should_use_my_bool_instead() fn_format_relative_to_data_home(char * to, const char *name, + const char *dir, const char *extension); +extern uint mysql_data_home_len; +extern char *mysql_data_home,server_version[60], + mysql_real_data_home[], mysql_unpacked_real_data_home[]; +extern CHARSET_INFO *character_set_filesystem; +extern char reg_ext[20]; +extern uint reg_ext_length; +extern ulong specialflag; +extern uint lower_case_table_names; +extern In_C_you_should_use_my_bool_instead() mysqld_embedded; +extern my_bool opt_large_pages; +extern uint opt_large_page_size; +extern struct system_variables global_system_variables; +uint strconvert(CHARSET_INFO *from_cs, const char *from, + CHARSET_INFO *to_cs, char *to, uint to_length, uint *errors); +uint filename_to_tablename(const char *from, char *to, uint to_length); +uint tablename_to_filename(const char *from, char *to, uint to_length); diff --git a/sql/set_var.cc b/sql/set_var.cc index 7d9d88f0281..4259c3a6aaf 100644 --- a/sql/set_var.cc +++ b/sql/set_var.cc @@ -1162,6 +1162,21 @@ void fix_slave_exec_mode(enum_var_type type) bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT); } + +bool sys_var_thd_binlog_format::check(THD *thd, set_var *var) { + /* + All variables that affect writing to binary log (either format or + turning logging on and off) use the same checking. We call the + superclass ::check function to assign the variable correctly, and + then check the value. + */ + bool result= sys_var_thd_enum::check(thd, var); + if (!result) + result= check_log_update(thd, var); + return result; +} + + bool sys_var_thd_binlog_format::is_readonly() const { /* diff --git a/sql/set_var.h b/sql/set_var.h index 603c3114d0e..8ae97c6502d 100644 --- a/sql/set_var.h +++ b/sql/set_var.h @@ -1126,6 +1126,7 @@ public: &binlog_format_typelib, fix_binlog_format_after_update) {}; + bool check(THD *thd, set_var *var); bool is_readonly() const; }; diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc index 226d41e0fb5..0043ef09229 100644 --- a/sql/sql_acl.cc +++ b/sql/sql_acl.cc @@ -3092,12 +3092,8 @@ int mysql_table_grant(THD *thd, TABLE_LIST *table_list, continue; // Add next user } - db_name= (table_list->view_db.length ? - table_list->view_db.str : - table_list->db); - table_name= (table_list->view_name.length ? - table_list->view_name.str : - table_list->table_name); + db_name= table_list->get_db_name(); + table_name= table_list->get_table_name(); /* Find/create cached table grant */ grant_table= table_hash_search(Str->host.str, NullS, db_name, @@ -3907,8 +3903,8 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables, if (!want_access) continue; // ok - if (!(~table->grant.privilege & want_access) || - table->derived || table->schema_table) + if (!(~table->grant.privilege & want_access) || + table->is_anonymous_derived_table() || table->schema_table) { /* It is subquery in the FROM clause. VIEW set table->derived after @@ -3926,8 +3922,8 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables, continue; } if (!(grant_table= table_hash_search(sctx->host, sctx->ip, - table->db, sctx->priv_user, - table->table_name,0))) + table->get_db_name(), sctx->priv_user, + table->get_table_name(), FALSE))) { want_access &= ~table->grant.privilege; goto err; // No grants @@ -3963,7 +3959,7 @@ err: command, sctx->priv_user, sctx->host_or_ip, - table ? table->table_name : "unknown"); + table ? table->get_table_name() : "unknown"); } DBUG_RETURN(1); } @@ -4118,7 +4114,7 @@ bool check_column_grant_in_table_ref(THD *thd, TABLE_LIST * table_ref, @retval 1 Falure @details This function walks over the columns of a table reference The columns may originate from different tables, depending on the kind of - table reference, e.g. join. + table reference, e.g. join, view. For each table it will retrieve the grant information and will use it to check the required access privileges for the fields requested from it. */ @@ -4133,6 +4129,11 @@ bool check_grant_all_columns(THD *thd, ulong want_access_arg, GRANT_INFO *grant; /* Initialized only to make gcc happy */ GRANT_TABLE *grant_table= NULL; + /* + Flag that gets set if privilege checking has to be performed on column + level. + */ + bool using_column_privileges= FALSE; rw_rdlock(&LOCK_grant); @@ -4140,10 +4141,10 @@ bool check_grant_all_columns(THD *thd, ulong want_access_arg, { const char *field_name= fields->name(); - if (table_name != fields->table_name()) + if (table_name != fields->get_table_name()) { - table_name= fields->table_name(); - db_name= fields->db_name(); + table_name= fields->get_table_name(); + db_name= fields->get_db_name(); grant= fields->grant(); /* get a fresh one for each table */ want_access= want_access_arg & ~grant->privilege; @@ -4169,6 +4170,8 @@ bool check_grant_all_columns(THD *thd, ulong want_access_arg, GRANT_COLUMN *grant_column= column_hash_search(grant_table, field_name, (uint) strlen(field_name)); + if (grant_column) + using_column_privileges= TRUE; if (!grant_column || (~grant_column->rights & want_access)) goto err; } @@ -4181,12 +4184,21 @@ err: char command[128]; get_privilege_desc(command, sizeof(command), want_access); - my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), - command, - sctx->priv_user, - sctx->host_or_ip, - fields->name(), - table_name); + /* + Do not give an error message listing a column name unless the user has + privilege to see all columns. + */ + if (using_column_privileges) + my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), + command, sctx->priv_user, + sctx->host_or_ip, table_name); + else + my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), + command, + sctx->priv_user, + sctx->host_or_ip, + fields->name(), + table_name); return 1; } diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 36b9d53ce85..39030462f0b 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -7620,9 +7620,34 @@ insert_fields(THD *thd, Name_resolution_context *context, const char *db_name, continue; #ifndef NO_EMBEDDED_ACCESS_CHECKS - /* Ensure that we have access rights to all fields to be inserted. */ - if (!((table && (table->grant.privilege & SELECT_ACL) || - tables->view && (tables->grant.privilege & SELECT_ACL))) && + /* + Ensure that we have access rights to all fields to be inserted. Under + some circumstances, this check may be skipped. + + - If any_privileges is true, skip the check. + + - If the SELECT privilege has been found as fulfilled already for both + the TABLE and TABLE_LIST objects (and both of these exist, of + course), the check is skipped. + + - If the SELECT privilege has been found fulfilled for the TABLE object + and the TABLE_LIST represents a derived table other than a view (see + below), the check is skipped. + + - If the TABLE_LIST object represents a view, we may skip checking if + the SELECT privilege has been found fulfilled for it, regardless of + the TABLE object. + + - If there is no TABLE object, the test is skipped if either + * the TABLE_LIST does not represent a view, or + * the SELECT privilege has been found fulfilled. + + A TABLE_LIST that is not a view may be a subquery, an + information_schema table, or a nested table reference. See the comment + for TABLE_LIST. + */ + if (!(table && !tables->view && (table->grant.privilege & SELECT_ACL) || + tables->view && (tables->grant.privilege & SELECT_ACL)) && !any_privileges) { field_iterator.set(tables); @@ -7676,19 +7701,19 @@ insert_fields(THD *thd, Name_resolution_context *context, const char *db_name, tables->is_natural_join); DBUG_ASSERT(item->type() == Item::FIELD_ITEM); Item_field *fld= (Item_field*) item; - const char *field_table_name= field_iterator.table_name(); + const char *field_table_name= field_iterator.get_table_name(); if (!tables->schema_table && !(fld->have_privileges= (get_column_grant(thd, field_iterator.grant(), - field_iterator.db_name(), + field_iterator.get_db_name(), field_table_name, fld->field_name) & VIEW_ANY_ACL))) { - my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY", + my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), "ANY", thd->security_ctx->priv_user, thd->security_ctx->host_or_ip, - fld->field_name, field_table_name); + field_table_name); DBUG_RETURN(TRUE); } } diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc index 375ffc882b4..f5566acbc6f 100644 --- a/sql/sql_cache.cc +++ b/sql/sql_cache.cc @@ -2633,7 +2633,7 @@ Query_cache::register_tables_from_list(TABLE_LIST *tables_used, tables_used; tables_used= tables_used->next_global, n++, block_table++) { - if (tables_used->derived && !tables_used->view) + if (tables_used->is_anonymous_derived_table()) { DBUG_PRINT("qcache", ("derived table skipped")); n--; diff --git a/sql/sql_class.cc b/sql/sql_class.cc index a23ebf367dc..98da93385cb 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -3502,6 +3502,21 @@ int THD::binlog_delete_row(TABLE* table, bool is_trans, } +int THD::binlog_remove_pending_rows_event(bool clear_maps) +{ + DBUG_ENTER(__FUNCTION__); + + if (!mysql_bin_log.is_open()) + DBUG_RETURN(0); + + mysql_bin_log.remove_pending_rows_event(this); + + if (clear_maps) + binlog_table_maps= 0; + + DBUG_RETURN(0); +} + int THD::binlog_flush_pending_rows_event(bool stmt_end) { DBUG_ENTER("THD::binlog_flush_pending_rows_event"); diff --git a/sql/sql_class.h b/sql/sql_class.h index 488a35ff070..be386adb8b1 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -1379,9 +1379,14 @@ public: Rows_log_event* binlog_get_pending_rows_event() const; void binlog_set_pending_rows_event(Rows_log_event* ev); int binlog_flush_pending_rows_event(bool stmt_end); + int binlog_remove_pending_rows_event(bool clear_maps); private: - uint binlog_table_maps; // Number of table maps currently in the binlog + /* + Number of outstanding table maps, i.e., table maps in the + transaction cache. + */ + uint binlog_table_maps; enum enum_binlog_flag { BINLOG_FLAG_UNSAFE_STMT_PRINTED, diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc index 10b42e11b26..41be98621a6 100644 --- a/sql/sql_derived.cc +++ b/sql/sql_derived.cc @@ -73,29 +73,59 @@ out: } -/* - Create temporary table structure (but do not fill it) - - SYNOPSIS - mysql_derived_prepare() - thd Thread handle - lex LEX for this thread - orig_table_list TABLE_LIST for the upper SELECT - - IMPLEMENTATION - Derived table is resolved with temporary table. - - After table creation, the above TABLE_LIST is updated with a new table. - - This function is called before any command containing derived table - is executed. - - Derived tables is stored in thd->derived_tables and freed in - close_thread_tables() - - RETURN - FALSE OK - TRUE Error +/** + @brief Create temporary table structure (but do not fill it). + + @param thd Thread handle + @param lex LEX for this thread + @param orig_table_list TABLE_LIST for the upper SELECT + + @details + + This function is called before any command containing derived tables is + executed. Currently the function is used for derived tables, i.e. + + - Anonymous derived tables, or + - Named derived tables (aka views) with the @c TEMPTABLE algorithm. + + The table reference, contained in @c orig_table_list, is updated with the + fields of a new temporary table. + + Derived tables are stored in @c thd->derived_tables and closed by + close_thread_tables(). + + This function is part of the procedure that starts in + open_and_lock_tables(), a procedure that - among other things - introduces + new table and table reference objects (to represent derived tables) that + don't exist in the privilege database. This means that normal privilege + checking cannot handle them. Hence this function does some extra tricks in + order to bypass normal privilege checking, by exploiting the fact that the + current state of privilege verification is attached as GRANT_INFO structures + on the relevant TABLE and TABLE_REF objects. + + For table references, the current state of accrued access is stored inside + TABLE_LIST::grant. Hence this function must update the state of fulfilled + privileges for the new TABLE_LIST, an operation which is normally performed + exclusively by the table and database access checking functions, + check_access() and check_grant(), respectively. This modification is done + for both views and anonymous derived tables: The @c SELECT privilege is set + as fulfilled by the user. However, if a view is referenced and the table + reference is queried against directly (see TABLE_LIST::referencing_view), + the state of privilege checking (GRANT_INFO struct) is copied as-is to the + temporary table. + + This function implements a signature called "derived table processor", and + is passed as a function pointer to mysql_handle_derived(). + + @note This function sets @c SELECT_ACL for @c TEMPTABLE views as well as + anonymous derived tables, but this is ok since later access checking will + distinguish between them. + + @see mysql_handle_derived(), mysql_derived_filling(), GRANT_INFO + + @return + false OK + true Error */ bool mysql_derived_prepare(THD *thd, LEX *lex, TABLE_LIST *orig_table_list) diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index df7b76491e0..5225dfe221e 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -3065,9 +3065,10 @@ bool select_insert::send_data(List<Item> &values) DBUG_RETURN(1); } } - + error= write_record(thd, table, &info); - + table->auto_increment_field_not_null= FALSE; + if (!error) { if (table->triggers || info.handle_duplicates == DUP_UPDATE) @@ -3523,7 +3524,8 @@ select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u) temporary table, we need to start a statement transaction. */ if ((thd->lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) == 0 && - thd->current_stmt_binlog_row_based) + thd->current_stmt_binlog_row_based && + mysql_bin_log.is_open()) { thd->binlog_start_trans_and_stmt(); } @@ -3620,10 +3622,11 @@ select_create::binlog_show_create_table(TABLE **tables, uint count) /* show_database */ TRUE); DBUG_ASSERT(result == 0); /* store_create_info() always return 0 */ - thd->binlog_query(THD::STMT_QUERY_TYPE, - query.ptr(), query.length(), - /* is_trans */ TRUE, - /* suppress_use */ FALSE); + if (mysql_bin_log.is_open()) + thd->binlog_query(THD::STMT_QUERY_TYPE, + query.ptr(), query.length(), + /* is_trans */ TRUE, + /* suppress_use */ FALSE); } void select_create::store_values(List<Item> &values) diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 620810fb13e..8f7f8cfd9c4 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -2083,13 +2083,15 @@ mysql_execute_command(THD *thd) #endif case SQLCOM_SHOW_STATUS_PROC: case SQLCOM_SHOW_STATUS_FUNC: - res= execute_sqlcom_select(thd, all_tables); + if (!(res= check_table_access(thd, SELECT_ACL, all_tables, UINT_MAX, FALSE))) + res= execute_sqlcom_select(thd, all_tables); break; case SQLCOM_SHOW_STATUS: { system_status_var old_status_var= thd->status_var; thd->initial_status_var= &old_status_var; - res= execute_sqlcom_select(thd, all_tables); + if (!(res= check_table_access(thd, SELECT_ACL, all_tables, UINT_MAX, FALSE))) + res= execute_sqlcom_select(thd, all_tables); /* Don't log SHOW STATUS commands to slow query log */ thd->server_status&= ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED); @@ -4872,6 +4874,8 @@ bool check_single_table_access(THD *thd, ulong privilege, /* Show only 1 table for check_grant */ if (!(all_tables->belong_to_view && (thd->lex->sql_command == SQLCOM_SHOW_FIELDS)) && + !(all_tables->view && + all_tables->effective_algorithm == VIEW_ALGORITHM_TMPTABLE) && check_grant(thd, privilege, all_tables, 0, 1, no_errors)) goto deny; @@ -5184,7 +5188,7 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables, continue; } - if (tables->derived || + if (tables->is_anonymous_derived_table() || (tables->table && (int)tables->table->s->tmp_table)) continue; thd->security_ctx= sctx; @@ -5194,12 +5198,14 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables, tables->grant.privilege= want_access; else if (tables->db && thd->db && strcmp(tables->db, thd->db) == 0) { - if (check_access(thd,want_access,tables->db,&tables->grant.privilege, - 0, no_errors, test(tables->schema_table))) + if (check_access(thd, want_access, tables->get_db_name(), + &tables->grant.privilege, 0, no_errors, + test(tables->schema_table))) goto deny; // Access denied } - else if (check_access(thd,want_access,tables->db,&tables->grant.privilege, - 0, no_errors, test(tables->schema_table))) + else if (check_access(thd, want_access, tables->get_db_name(), + &tables->grant.privilege, 0, no_errors, + test(tables->schema_table))) goto deny; } thd->security_ctx= backup_ctx; diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index baecf716cdd..04f73cb963b 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -10105,8 +10105,6 @@ show_param: { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_STATUS_PROC; - if (!sp_add_to_query_tables(YYTHD, lex, "mysql", "proc", TL_READ)) - MYSQL_YYABORT; if (prepare_schema_table(YYTHD, lex, 0, SCH_PROCEDURES)) MYSQL_YYABORT; } @@ -10114,8 +10112,6 @@ show_param: { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_STATUS_FUNC; - if (!sp_add_to_query_tables(YYTHD, lex, "mysql", "proc", TL_READ)) - MYSQL_YYABORT; if (prepare_schema_table(YYTHD, lex, 0, SCH_PROCEDURES)) MYSQL_YYABORT; } diff --git a/sql/table.cc b/sql/table.cc index 58cbde74822..40264a7cbb3 100644 --- a/sql/table.cc +++ b/sql/table.cc @@ -2993,16 +2993,27 @@ void TABLE_LIST::calc_md5(char *buffer) } -/* - set underlying TABLE for table place holder of VIEW +/** + @brief Set underlying table for table place holder of view. - DESCRIPTION - Replace all views that only uses one table with the table itself. - This allows us to treat the view as a simple table and even update - it (it is a kind of optimisation) + @details - SYNOPSIS - TABLE_LIST::set_underlying_merge() + Replace all views that only use one table with the table itself. This + allows us to treat the view as a simple table and even update it (it is a + kind of optimization). + + @note + + This optimization is potentially dangerous as it makes views + masquerade as base tables: Views don't have the pointer TABLE_LIST::table + set to non-@c NULL. + + We may have the case where a view accesses tables not normally accessible + in the current Security_context (only in the definer's + Security_context). According to the table's GRANT_INFO (TABLE::grant), + access is fulfilled, but this is implicitly meant in the definer's security + context. Hence we must never look at only a TABLE's GRANT_INFO without + looking at the one of the referring TABLE_LIST. */ void TABLE_LIST::set_underlying_merge() @@ -4082,7 +4093,7 @@ void Field_iterator_table_ref::next() } -const char *Field_iterator_table_ref::table_name() +const char *Field_iterator_table_ref::get_table_name() { if (table_ref->view) return table_ref->view_name.str; @@ -4095,7 +4106,7 @@ const char *Field_iterator_table_ref::table_name() } -const char *Field_iterator_table_ref::db_name() +const char *Field_iterator_table_ref::get_db_name() { if (table_ref->view) return table_ref->view_db.str; diff --git a/sql/table.h b/sql/table.h index da0e089794f..d21a9eefae8 100644 --- a/sql/table.h +++ b/sql/table.h @@ -66,13 +66,63 @@ typedef struct st_order { table_map used, depend_map; } ORDER; +/** + @brief The current state of the privilege checking process for the current + user, SQL statement and SQL object. + + @details The privilege checking process is divided into phases depending on + the level of the privilege to be checked and the type of object to be + accessed. Due to the mentioned scattering of privilege checking + functionality, it is necessary to keep track of the state of the + process. This information is stored in privilege, want_privilege, and + orig_want_privilege. + + A GRANT_INFO also serves as a cache of the privilege hash tables. Relevant + members are grant_table and version. + */ typedef struct st_grant_info { + /** + @brief A copy of the privilege information regarding the current host, + database, object and user. + + @details The version of this copy is found in GRANT_INFO::version. + */ GRANT_TABLE *grant_table; + /** + @brief Used for cache invalidation when caching privilege information. + + @details The privilege information is stored on disk, with dedicated + caches residing in memory: table-level and column-level privileges, + respectively, have their own dedicated caches. + + The GRANT_INFO works as a level 1 cache with this member updated to the + current value of the global variable @c grant_version (@c static variable + in sql_acl.cc). It is updated Whenever the GRANT_INFO is refreshed from + the level 2 cache. The level 2 cache is the @c column_priv_hash structure + (@c static variable in sql_acl.cc) + + @see grant_version + */ uint version; + /** + @brief The set of privileges that the current user has fulfilled for a + certain host, database, and object. + + @details This field is continually updated throughout the access checking + process. In each step the "wanted privilege" is checked against the + fulfilled privileges. When/if the intersection of these sets is empty, + access is granted. + + The set is implemented as a bitmap, with the bits defined in sql_acl.h. + */ ulong privilege; + /** + @brief the set of privileges that the current user needs to fulfil in + order to carry out the requested operation. + */ ulong want_privilege; - /* + /** Stores the requested access acl of top level tables list. Is used to check access rights to the underlying tables of a view. */ @@ -1104,6 +1154,27 @@ struct TABLE_LIST can see this lists can't be merged) */ TABLE_LIST *correspondent_table; + /** + @brief Normally, this field is non-null for anonymous derived tables only. + + @details This field is set to non-null for + + - Anonymous derived tables, In this case it points to the SELECT_LEX_UNIT + representing the derived table. E.g. for a query + + @verbatim SELECT * FROM (SELECT a FROM t1) b @endverbatim + + For the @c TABLE_LIST representing the derived table @c b, @c derived + points to the SELECT_LEX_UNIT representing the result of the query within + parenteses. + + - Views. This is set for views with @verbatim ALGORITHM = TEMPTABLE + @endverbatim by mysql_make_view(). + + @note Inside views, a subquery in the @c FROM clause is not allowed. + @note Do not use this field to separate views/base tables/anonymous + derived tables. Use TABLE_LIST::is_anonymous_derived_table(). + */ st_select_lex_unit *derived; /* SELECT_LEX_UNIT of derived table */ ST_SCHEMA_TABLE *schema_table; /* Information_schema table */ st_select_lex *schema_select_lex; @@ -1169,7 +1240,15 @@ struct TABLE_LIST ulonglong file_version; /* version of file's field set */ ulonglong updatable_view; /* VIEW can be updated */ ulonglong revision; /* revision control number */ - ulonglong algorithm; /* 0 any, 1 tmp tables , 2 merging */ + /** + @brief The declared algorithm, if this is a view. + @details One of + - VIEW_ALGORITHM_UNDEFINED + - VIEW_ALGORITHM_TMPTABLE + - VIEW_ALGORITHM_MERGE + @to do Replace with an enum + */ + ulonglong algorithm; ulonglong view_suid; /* view is suid (TRUE dy default) */ ulonglong with_check; /* WITH CHECK OPTION */ /* @@ -1177,7 +1256,15 @@ struct TABLE_LIST algorithm) */ uint8 effective_with_check; - uint8 effective_algorithm; /* which algorithm was really used */ + /** + @brief The view algorithm that is actually used, if this is a view. + @details One of + - VIEW_ALGORITHM_UNDEFINED + - VIEW_ALGORITHM_TMPTABLE + - VIEW_ALGORITHM_MERGE + @to do Replace with an enum + */ + uint8 effective_algorithm; GRANT_INFO grant; /* data need by some engines in query cache*/ ulonglong engine_data; @@ -1362,6 +1449,26 @@ struct TABLE_LIST m_table_ref_version= s->get_table_ref_version(); } + /** + @brief True if this TABLE_LIST represents an anonymous derived table, + i.e. the result of a subquery. + */ + bool is_anonymous_derived_table() const { return derived && !view; } + + /** + @brief Returns the name of the database that the referenced table belongs + to. + */ + char *get_db_name() { return view != NULL ? view_db.str : db; } + + /** + @brief Returns the name of the table that this TABLE_LIST represents. + + @details The unqualified table name or view name for a table or view, + respectively. + */ + char *get_table_name() { return view != NULL ? view_name.str : table_name; } + private: bool prep_check_option(THD *thd, uint8 check_opt_type); bool prep_where(THD *thd, Item **conds, bool no_where_clause); @@ -1491,8 +1598,8 @@ public: bool end_of_fields() { return (table_ref == last_leaf && field_it->end_of_fields()); } const char *name() { return field_it->name(); } - const char *table_name(); - const char *db_name(); + const char *get_table_name(); + const char *get_db_name(); GRANT_INFO *grant(); Item *create_item(THD *thd) { return field_it->create_item(thd); } Field *field() { return field_it->field(); } diff --git a/win/build-vs9.bat b/win/build-vs9.bat new file mode 100644 index 00000000000..09f1e343013 --- /dev/null +++ b/win/build-vs9.bat @@ -0,0 +1,18 @@ +@echo off + +REM Copyright (C) 2006 MySQL AB +REM +REM This program is free software; you can redistribute it and/or modify +REM it under the terms of the GNU General Public License as published by +REM the Free Software Foundation; version 2 of the License. +REM +REM This program is distributed in the hope that it will be useful, +REM but WITHOUT ANY WARRANTY; without even the implied warranty of +REM MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +REM GNU General Public License for more details. +REM +REM You should have received a copy of the GNU General Public License +REM along with this program; if not, write to the Free Software +REM Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +cmake -G "Visual Studio 9 2008" + diff --git a/win/build-vs9_x64.bat b/win/build-vs9_x64.bat new file mode 100644 index 00000000000..61c7253132d --- /dev/null +++ b/win/build-vs9_x64.bat @@ -0,0 +1,18 @@ +@echo off + +REM Copyright (C) 2006 MySQL AB +REM +REM This program is free software; you can redistribute it and/or modify +REM it under the terms of the GNU General Public License as published by +REM the Free Software Foundation; version 2 of the License. +REM +REM This program is distributed in the hope that it will be useful, +REM but WITHOUT ANY WARRANTY; without even the implied warranty of +REM MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +REM GNU General Public License for more details. +REM +REM You should have received a copy of the GNU General Public License +REM along with this program; if not, write to the Free Software +REM Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +cmake -G "Visual Studio 9 2008 Win64" + diff --git a/zlib/zutil.h b/zlib/zutil.h index b7d5eff81b6..4482957d6ac 100644 --- a/zlib/zutil.h +++ b/zlib/zutil.h @@ -194,7 +194,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # ifdef __TURBOC__ # define NO_vsnprintf # endif -# ifdef WIN32 +# if defined(WIN32) && (!defined(_MSC_VER) || _MSC_VER < 1500) /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ # if !defined(vsnprintf) && !defined(NO_vsnprintf) # define vsnprintf _vsnprintf |